RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Cleaned up alacenc.c 

Signed-off-by: Ronald S. Bultje <rsbultje@gmail.com>
This commit is contained in:
Nathan Adil Maxson 2011-11-30 21:37:33 -08:00 committed by Ronald S. Bultje
parent 04403ec2e4
commit d0fd6fc201
1 changed files with 54 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
libavcodec/alacenc.c
View File

@ -75,20 +75,22 @@ typedef struct AlacEncodeContext {
} AlacEncodeContext; } AlacEncodeContext;
static void init_sample_buffers(AlacEncodeContext *s, const int16_t *input_samples) static void init_sample_buffers(AlacEncodeContext *s,
const int16_t *input_samples)
{ {
int ch, i; int ch, i;
for(ch=0;ch<s->avctx->channels;ch++) { for (ch = 0; ch < s->avctx->channels; ch++) {
const int16_t *sptr = input_samples + ch; const int16_t *sptr = input_samples + ch;
for(i=0;i<s->avctx->frame_size;i++) { for (i = 0; i < s->avctx->frame_size; i++) {
s->sample_buf[ch][i] = *sptr; s->sample_buf[ch][i] = *sptr;
sptr += s->avctx->channels; sptr += s->avctx->channels;
} }
} }
} }
static void encode_scalar(AlacEncodeContext *s, int x, int k, int write_sample_size) static void encode_scalar(AlacEncodeContext *s, int x,
int k, int write_sample_size)
{ {
int divisor, q, r; int divisor, q, r;
@ -97,17 +99,17 @@ static void encode_scalar(AlacEncodeContext *s, int x, int k, int write_sample_s
q = x / divisor; q = x / divisor;
r = x % divisor; r = x % divisor;
if(q > 8) { if (q > 8) {
// write escape code and sample value directly // write escape code and sample value directly
put_bits(&s->pbctx, 9, ALAC_ESCAPE_CODE); put_bits(&s->pbctx, 9, ALAC_ESCAPE_CODE);
put_bits(&s->pbctx, write_sample_size, x); put_bits(&s->pbctx, write_sample_size, x);
} else { } else {
if(q) if (q)
put_bits(&s->pbctx, q, (1<<q) - 1); put_bits(&s->pbctx, q, (1<<q) - 1);
put_bits(&s->pbctx, 1, 0); put_bits(&s->pbctx, 1, 0);
if(k != 1) { if (k != 1) {
if(r > 0) if (r > 0)
put_bits(&s->pbctx, k, r+1); put_bits(&s->pbctx, k, r+1);
else else
put_bits(&s->pbctx, k-1, 0); put_bits(&s->pbctx, k-1, 0);
@ -164,7 +166,7 @@ static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
/* calculate sum of 2nd order residual for each channel */ /* calculate sum of 2nd order residual for each channel */
sum[0] = sum[1] = sum[2] = sum[3] = 0; sum[0] = sum[1] = sum[2] = sum[3] = 0;
for(i=2; i<n; i++) { for (i = 2; i < n; i++) {
lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2]; lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2]; rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
sum[2] += FFABS((lt + rt) >> 1); sum[2] += FFABS((lt + rt) >> 1);
@ -181,8 +183,8 @@ static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
/* return mode with lowest score */ /* return mode with lowest score */
best = 0; best = 0;
for(i=1; i<4; i++) { for (i = 1; i < 4; i++) {
if(score[i] < score[best]) { if (score[i] < score[best]) {
best = i; best = i;
} }
} }
@ -205,7 +207,7 @@ static void alac_stereo_decorrelation(AlacEncodeContext *s)
break; break;
case ALAC_CHMODE_LEFT_SIDE: case ALAC_CHMODE_LEFT_SIDE:
for(i=0; i<n; i++) { for (i = 0; i < n; i++) {
right[i] = left[i] - right[i]; right[i] = left[i] - right[i];
} }
s->interlacing_leftweight = 1; s->interlacing_leftweight = 1;
@ -213,7 +215,7 @@ static void alac_stereo_decorrelation(AlacEncodeContext *s)
break; break;
case ALAC_CHMODE_RIGHT_SIDE: case ALAC_CHMODE_RIGHT_SIDE:
for(i=0; i<n; i++) { for (i = 0; i < n; i++) {
tmp = right[i]; tmp = right[i];
right[i] = left[i] - right[i]; right[i] = left[i] - right[i];
left[i] = tmp + (right[i] >> 31); left[i] = tmp + (right[i] >> 31);
@ -223,7 +225,7 @@ static void alac_stereo_decorrelation(AlacEncodeContext *s)
break; break;
default: default:
for(i=0; i<n; i++) { for (i = 0; i < n; i++) {
tmp = left[i]; tmp = left[i];
left[i] = (tmp + right[i]) >> 1; left[i] = (tmp + right[i]) >> 1;
right[i] = tmp - right[i]; right[i] = tmp - right[i];
@ -239,10 +241,10 @@ static void alac_linear_predictor(AlacEncodeContext *s, int ch)
int i; int i;
AlacLPCContext lpc = s->lpc[ch]; AlacLPCContext lpc = s->lpc[ch];
if(lpc.lpc_order == 31) { if (lpc.lpc_order == 31) {
s->predictor_buf[0] = s->sample_buf[ch][0]; s->predictor_buf[0] = s->sample_buf[ch][0];
for(i=1; i<s->avctx->frame_size; i++) for (i = 1; i < s->avctx->frame_size; i++)
s->predictor_buf[i] = s->sample_buf[ch][i] - s->sample_buf[ch][i-1]; s->predictor_buf[i] = s->sample_buf[ch][i] - s->sample_buf[ch][i-1];
return; return;
@ -250,17 +252,17 @@ static void alac_linear_predictor(AlacEncodeContext *s, int ch)
// generalised linear predictor // generalised linear predictor
if(lpc.lpc_order > 0) { if (lpc.lpc_order > 0) {
int32_t *samples = s->sample_buf[ch]; int32_t *samples = s->sample_buf[ch];
int32_t *residual = s->predictor_buf; int32_t *residual = s->predictor_buf;
// generate warm-up samples // generate warm-up samples
residual[0] = samples[0]; residual[0] = samples[0];
for(i=1;i<=lpc.lpc_order;i++) for (i = 1; i <= lpc.lpc_order; i++)
residual[i] = samples[i] - samples[i-1]; residual[i] = samples[i] - samples[i-1];
// perform lpc on remaining samples // perform lpc on remaining samples
for(i = lpc.lpc_order + 1; i < s->avctx->frame_size; i++) { for (i = lpc.lpc_order + 1; i < s->avctx->frame_size; i++) {
int sum = 1 << (lpc.lpc_quant - 1), res_val, j; int sum = 1 << (lpc.lpc_quant - 1), res_val, j;
for (j = 0; j < lpc.lpc_order; j++) { for (j = 0; j < lpc.lpc_order; j++) {
@ -303,7 +305,7 @@ static void alac_entropy_coder(AlacEncodeContext *s)
int sign_modifier = 0, i, k; int sign_modifier = 0, i, k;
int32_t *samples = s->predictor_buf; int32_t *samples = s->predictor_buf;
for(i=0;i < s->avctx->frame_size;) { for (i = 0; i < s->avctx->frame_size;) {
int x; int x;
k = av_log2((history >> 9) + 3); k = av_log2((history >> 9) + 3);
@ -320,15 +322,15 @@ static void alac_entropy_coder(AlacEncodeContext *s)
- ((history * s->rc.history_mult) >> 9); - ((history * s->rc.history_mult) >> 9);
sign_modifier = 0; sign_modifier = 0;
if(x > 0xFFFF) if (x > 0xFFFF)
history = 0xFFFF; history = 0xFFFF;
if((history < 128) && (i < s->avctx->frame_size)) { if (history < 128 && i < s->avctx->frame_size) {
unsigned int block_size = 0; unsigned int block_size = 0;
k = 7 - av_log2(history) + ((history + 16) >> 6); k = 7 - av_log2(history) + ((history + 16) >> 6);
while((*samples == 0) && (i < s->avctx->frame_size)) { while (*samples == 0 && i < s->avctx->frame_size) {
samples++; samples++;
i++; i++;
block_size++; block_size++;
@ -347,12 +349,12 @@ static void write_compressed_frame(AlacEncodeContext *s)
{ {
int i, j; int i, j;
if(s->avctx->channels == 2) if (s->avctx->channels == 2)
alac_stereo_decorrelation(s); alac_stereo_decorrelation(s);
put_bits(&s->pbctx, 8, s->interlacing_shift); put_bits(&s->pbctx, 8, s->interlacing_shift);
put_bits(&s->pbctx, 8, s->interlacing_leftweight); put_bits(&s->pbctx, 8, s->interlacing_leftweight);
for(i=0;i<s->avctx->channels;i++) { for (i = 0; i < s->avctx->channels; i++) {
calc_predictor_params(s, i); calc_predictor_params(s, i);
@ -362,14 +364,14 @@ static void write_compressed_frame(AlacEncodeContext *s)
put_bits(&s->pbctx, 3, s->rc.rice_modifier); put_bits(&s->pbctx, 3, s->rc.rice_modifier);
put_bits(&s->pbctx, 5, s->lpc[i].lpc_order); put_bits(&s->pbctx, 5, s->lpc[i].lpc_order);
// predictor coeff. table // predictor coeff. table
for(j=0;j<s->lpc[i].lpc_order;j++) { for (j = 0; j < s->lpc[i].lpc_order; j++) {
put_sbits(&s->pbctx, 16, s->lpc[i].lpc_coeff[j]); put_sbits(&s->pbctx, 16, s->lpc[i].lpc_coeff[j]);
} }
} }
// apply lpc and entropy coding to audio samples // apply lpc and entropy coding to audio samples
for(i=0;i<s->avctx->channels;i++) { for (i = 0; i < s->avctx->channels; i++) {
alac_linear_predictor(s, i); alac_linear_predictor(s, i);
alac_entropy_coder(s); alac_entropy_coder(s);
} }
@ -384,13 +386,13 @@ static av_cold int alac_encode_init(AVCodecContext *avctx)
avctx->frame_size = DEFAULT_FRAME_SIZE; avctx->frame_size = DEFAULT_FRAME_SIZE;
avctx->bits_per_coded_sample = DEFAULT_SAMPLE_SIZE; avctx->bits_per_coded_sample = DEFAULT_SAMPLE_SIZE;
if(avctx->sample_fmt != AV_SAMPLE_FMT_S16) { if (avctx->sample_fmt != AV_SAMPLE_FMT_S16) {
av_log(avctx, AV_LOG_ERROR, "only pcm_s16 input samples are supported\n"); av_log(avctx, AV_LOG_ERROR, "only pcm_s16 input samples are supported\n");
return -1; return -1;
} }
// Set default compression level // Set default compression level
if(avctx->compression_level == FF_COMPRESSION_DEFAULT) if (avctx->compression_level == FF_COMPRESSION_DEFAULT)
s->compression_level = 2; s->compression_level = 2;
else else
s->compression_level = av_clip(avctx->compression_level, 0, 2); s->compression_level = av_clip(avctx->compression_level, 0, 2);
@ -411,21 +413,23 @@ static av_cold int alac_encode_init(AVCodecContext *avctx)
AV_WB8 (alac_extradata+17, avctx->bits_per_coded_sample); AV_WB8 (alac_extradata+17, avctx->bits_per_coded_sample);
AV_WB8 (alac_extradata+21, avctx->channels); AV_WB8 (alac_extradata+21, avctx->channels);
AV_WB32(alac_extradata+24, s->max_coded_frame_size); AV_WB32(alac_extradata+24, s->max_coded_frame_size);
AV_WB32(alac_extradata+28, avctx->sample_rate*avctx->channels*avctx->bits_per_coded_sample); // average bitrate AV_WB32(alac_extradata+28,
avctx->sample_rate * avctx->channels * avctx->bits_per_coded_sample); // average bitrate
AV_WB32(alac_extradata+32, avctx->sample_rate); AV_WB32(alac_extradata+32, avctx->sample_rate);
// Set relevant extradata fields // Set relevant extradata fields
if(s->compression_level > 0) { if (s->compression_level > 0) {
AV_WB8(alac_extradata+18, s->rc.history_mult); AV_WB8(alac_extradata+18, s->rc.history_mult);
AV_WB8(alac_extradata+19, s->rc.initial_history); AV_WB8(alac_extradata+19, s->rc.initial_history);
AV_WB8(alac_extradata+20, s->rc.k_modifier); AV_WB8(alac_extradata+20, s->rc.k_modifier);
} }
s->min_prediction_order = DEFAULT_MIN_PRED_ORDER; s->min_prediction_order = DEFAULT_MIN_PRED_ORDER;
if(avctx->min_prediction_order >= 0) { if (avctx->min_prediction_order >= 0) {
if(avctx->min_prediction_order < MIN_LPC_ORDER || if (avctx->min_prediction_order < MIN_LPC_ORDER ||
avctx->min_prediction_order > ALAC_MAX_LPC_ORDER) { avctx->min_prediction_order > ALAC_MAX_LPC_ORDER) {
av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n", avctx->min_prediction_order); av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
avctx->min_prediction_order);
return -1; return -1;
} }
@ -433,18 +437,20 @@ static av_cold int alac_encode_init(AVCodecContext *avctx)
} }
s->max_prediction_order = DEFAULT_MAX_PRED_ORDER; s->max_prediction_order = DEFAULT_MAX_PRED_ORDER;
if(avctx->max_prediction_order >= 0) { if (avctx->max_prediction_order >= 0) {
if(avctx->max_prediction_order < MIN_LPC_ORDER || if (avctx->max_prediction_order < MIN_LPC_ORDER ||
avctx->max_prediction_order > ALAC_MAX_LPC_ORDER) { avctx->max_prediction_order > ALAC_MAX_LPC_ORDER) {
av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n", avctx->max_prediction_order); av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
avctx->max_prediction_order);
return -1; return -1;
} }
s->max_prediction_order = avctx->max_prediction_order; s->max_prediction_order = avctx->max_prediction_order;
} }
if(s->max_prediction_order < s->min_prediction_order) { if (s->max_prediction_order < s->min_prediction_order) {
av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n", av_log(avctx, AV_LOG_ERROR,
"invalid prediction orders: min=%d max=%d\n",
s->min_prediction_order, s->max_prediction_order); s->min_prediction_order, s->max_prediction_order);
return -1; return -1;
} }
@ -469,12 +475,12 @@ static int alac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
PutBitContext *pb = &s->pbctx; PutBitContext *pb = &s->pbctx;
int i, out_bytes, verbatim_flag = 0; int i, out_bytes, verbatim_flag = 0;
if(avctx->frame_size > DEFAULT_FRAME_SIZE) { if (avctx->frame_size > DEFAULT_FRAME_SIZE) {
av_log(avctx, AV_LOG_ERROR, "input frame size exceeded\n"); av_log(avctx, AV_LOG_ERROR, "input frame size exceeded\n");
return -1; return -1;
} }
if(buf_size < 2*s->max_coded_frame_size) { if (buf_size < 2 * s->max_coded_frame_size) {
av_log(avctx, AV_LOG_ERROR, "buffer size is too small\n"); av_log(avctx, AV_LOG_ERROR, "buffer size is too small\n");
return -1; return -1;
} }
@ -482,11 +488,11 @@ static int alac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
verbatim: verbatim:
init_put_bits(pb, frame, buf_size); init_put_bits(pb, frame, buf_size);
if((s->compression_level == 0) || verbatim_flag) { if (s->compression_level == 0 || verbatim_flag) {
// Verbatim mode // Verbatim mode
const int16_t *samples = data; const int16_t *samples = data;
write_frame_header(s, 1); write_frame_header(s, 1);
for(i=0; i<avctx->frame_size*avctx->channels; i++) { for (i = 0; i < avctx->frame_size * avctx->channels; i++) {
put_sbits(pb, 16, *samples++); put_sbits(pb, 16, *samples++);
} }
} else { } else {
@ -499,9 +505,9 @@ verbatim:
flush_put_bits(pb); flush_put_bits(pb);
out_bytes = put_bits_count(pb) >> 3; out_bytes = put_bits_count(pb) >> 3;
if(out_bytes > s->max_coded_frame_size) { if (out_bytes > s->max_coded_frame_size) {
/* frame too large. use verbatim mode */ /* frame too large. use verbatim mode */
if(verbatim_flag || (s->compression_level == 0)) { if (verbatim_flag || s->compression_level == 0) {
/* still too large. must be an error. */ /* still too large. must be an error. */
av_log(avctx, AV_LOG_ERROR, "error encoding frame\n"); av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
return -1; return -1;
@ -532,6 +538,7 @@ AVCodec ff_alac_encoder = {
.encode = alac_encode_frame, .encode = alac_encode_frame,
.close = alac_encode_close, .close = alac_encode_close,
.capabilities = CODEC_CAP_SMALL_LAST_FRAME, .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"), .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
}; };