diff --git a/libavcodec/alac.c b/libavcodec/alac.c index 8c8e83076f..1c850986c8 100644 --- a/libavcodec/alac.c +++ b/libavcodec/alac.c @@ -112,14 +112,13 @@ static const uint16_t alac_channel_layouts[8] = { AV_CH_LAYOUT_7POINT1_WIDE_BACK }; -static inline unsigned int decode_scalar(GetBitContext *gb, int k, - int readsamplesize) +static inline unsigned int decode_scalar(GetBitContext *gb, int k, int bps) { unsigned int x = get_unary_0_9(gb); if (x > 8) { /* RICE THRESHOLD */ /* use alternative encoding */ - x = get_bits_long(gb, readsamplesize); + x = get_bits_long(gb, bps); } else if (k != 1) { int extrabits = show_bits(gb, k); @@ -135,28 +134,25 @@ static inline unsigned int decode_scalar(GetBitContext *gb, int k, return x; } -static void bastardized_rice_decompress(ALACContext *alac, - int32_t *output_buffer, - int output_size, - int readsamplesize, - int rice_history_mult) +static void rice_decompress(ALACContext *alac, int32_t *output_buffer, + int nb_samples, int bps, int rice_history_mult) { - int output_count; + int i; unsigned int history = alac->rice_initial_history; int sign_modifier = 0; - for (output_count = 0; output_count < output_size; output_count++) { + for (i = 0; i < nb_samples; i++) { int k; unsigned int x; /* read k, that is bits as is */ k = av_log2((history >> 9) + 3); k = FFMIN(k, alac->rice_limit); - x = decode_scalar(&alac->gb, k, readsamplesize); + x = decode_scalar(&alac->gb, k, bps); x += sign_modifier; sign_modifier = 0; - output_buffer[output_count] = (x >> 1) ^ -(x & 1); + output_buffer[i] = (x >> 1) ^ -(x & 1); /* now update the history */ if (x > 0xffff) @@ -166,7 +162,7 @@ static void bastardized_rice_decompress(ALACContext *alac, ((history * rice_history_mult) >> 9); /* special case: there may be compressed blocks of 0 */ - if ((history < 128) && (output_count+1 < output_size)) { + if ((history < 128) && (i + 1 < nb_samples)) { int block_size; k = 7 - av_log2(history) + ((history + 16) >> 6 /* / 64 */); @@ -175,13 +171,15 @@ static void bastardized_rice_decompress(ALACContext *alac, block_size = decode_scalar(&alac->gb, k, 16); if (block_size > 0) { - if(block_size >= output_size - output_count){ - av_log(alac->avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", block_size, output_size, output_count); - block_size= output_size - output_count - 1; + if (block_size >= nb_samples - i) { + av_log(alac->avctx, AV_LOG_ERROR, + "invalid zero block size of %d %d %d\n", block_size, + nb_samples, i); + block_size = nb_samples - i - 1; } - memset(&output_buffer[output_count + 1], 0, + memset(&output_buffer[i + 1], 0, block_size * sizeof(*output_buffer)); - output_count += block_size; + i += block_size; } if (block_size <= 0xffff) @@ -197,93 +195,86 @@ static inline int sign_only(int v) return v ? FFSIGN(v) : 0; } -static void predictor_decompress_fir_adapt(int32_t *error_buffer, - int32_t *buffer_out, - int output_size, - int readsamplesize, - int16_t *predictor_coef_table, - int predictor_coef_num, - int predictor_quantitization) +static void lpc_prediction(int32_t *error_buffer, int32_t *buffer_out, + int nb_samples, int bps, int16_t *lpc_coefs, + int lpc_order, int lpc_quant) { int i; /* first sample always copies */ *buffer_out = *error_buffer; - if (output_size <= 1) + if (nb_samples <= 1) return; - if (!predictor_coef_num) { + if (!lpc_order) { memcpy(&buffer_out[1], &error_buffer[1], - (output_size - 1) * sizeof(*buffer_out)); + (nb_samples - 1) * sizeof(*buffer_out)); return; } - if (predictor_coef_num == 31) { + if (lpc_order == 31) { /* simple 1st-order prediction */ - for (i = 1; i < output_size; i++) { + for (i = 1; i < nb_samples; i++) { buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i], - readsamplesize); + bps); } return; } /* read warm-up samples */ - for (i = 0; i < predictor_coef_num; i++) { + for (i = 0; i < lpc_order; i++) { buffer_out[i + 1] = sign_extend(buffer_out[i] + error_buffer[i + 1], - readsamplesize); + bps); } /* NOTE: 4 and 8 are very common cases that could be optimized. */ /* general case */ - for (i = predictor_coef_num; i < output_size - 1; i++) { + for (i = lpc_order; i < nb_samples - 1; i++) { int j; int val = 0; int error_val = error_buffer[i + 1]; int error_sign; - int d = buffer_out[i - predictor_coef_num]; + int d = buffer_out[i - lpc_order]; - for (j = 0; j < predictor_coef_num; j++) { - val += (buffer_out[i - j] - d) * - predictor_coef_table[j]; + for (j = 0; j < lpc_order; j++) { + val += (buffer_out[i - j] - d) * lpc_coefs[j]; } - val = (val + (1 << (predictor_quantitization - 1))) >> - predictor_quantitization; + val = (val + (1 << (lpc_quant - 1))) >> lpc_quant; val += d + error_val; - buffer_out[i + 1] = sign_extend(val, readsamplesize); + buffer_out[i + 1] = sign_extend(val, bps); /* adapt LPC coefficients */ error_sign = sign_only(error_val); if (error_sign) { - for (j = predictor_coef_num - 1; j >= 0 && error_val * error_sign > 0; j--) { + for (j = lpc_order - 1; j >= 0 && error_val * error_sign > 0; j--) { int sign; val = d - buffer_out[i - j]; sign = sign_only(val) * error_sign; - predictor_coef_table[j] -= sign; + lpc_coefs[j] -= sign; val *= sign; - error_val -= ((val >> predictor_quantitization) * - (predictor_coef_num - j)); + error_val -= (val >> lpc_quant) * (lpc_order - j); } } } } static void decorrelate_stereo(int32_t *buffer[2], - int numsamples, uint8_t interlacing_shift, - uint8_t interlacing_leftweight) + int nb_samples, uint8_t decorr_shift, + uint8_t decorr_left_weight) { int i; - for (i = 0; i < numsamples; i++) { + for (i = 0; i < nb_samples; i++) { int32_t a, b; a = buffer[0][i]; b = buffer[1][i]; - a -= (b * interlacing_leftweight) >> interlacing_shift; + a -= (b * decorr_left_weight) >> decorr_shift; b += a; buffer[0][i] = b; @@ -293,12 +284,12 @@ static void decorrelate_stereo(int32_t *buffer[2], static void append_extra_bits(int32_t *buffer[2], int32_t *extra_bits_buffer[2], - int extra_bits, int numchannels, int numsamples) + int extra_bits, int channels, int nb_samples) { int i, ch; - for (ch = 0; ch < numchannels; ch++) - for (i = 0; i < numsamples; i++) + for (ch = 0; ch < channels; ch++) + for (i = 0; i < nb_samples; i++) buffer[ch][i] = (buffer[ch][i] << extra_bits) | extra_bits_buffer[ch][i]; } @@ -306,11 +297,11 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index, int channels) { ALACContext *alac = avctx->priv_data; - int hassize; - unsigned int readsamplesize; + int has_size; + unsigned int bps; int is_compressed; - uint8_t interlacing_shift; - uint8_t interlacing_leftweight; + uint8_t decorr_shift; + uint8_t decorr_left_weight; uint32_t output_samples; int i, ch, ret; @@ -318,19 +309,19 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index, skip_bits(&alac->gb, 12); /* unused header bits */ /* the number of output samples is stored in the frame */ - hassize = get_bits1(&alac->gb); + has_size = get_bits1(&alac->gb); alac->extra_bits = get_bits(&alac->gb, 2) << 3; - readsamplesize = alac->sample_size - alac->extra_bits + channels - 1; - if (readsamplesize > 32) { - av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", readsamplesize); + bps = alac->sample_size - alac->extra_bits + channels - 1; + if (bps > 32) { + av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", bps); return AVERROR_PATCHWELCOME; } /* whether the frame is compressed */ is_compressed = !get_bits1(&alac->gb); - if (hassize) + if (has_size) output_samples = get_bits_long(&alac->gb, 32); else output_samples = alac->max_samples_per_frame; @@ -358,25 +349,24 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index, alac->nb_samples = output_samples; if (is_compressed) { - int16_t predictor_coef_table[2][32]; - int predictor_coef_num[2]; + int16_t lpc_coefs[2][32]; + int lpc_order[2]; int prediction_type[2]; - int prediction_quantitization[2]; - int ricemodifier[2]; + int lpc_quant[2]; + int rice_history_mult[2]; - interlacing_shift = get_bits(&alac->gb, 8); - interlacing_leftweight = get_bits(&alac->gb, 8); + decorr_shift = get_bits(&alac->gb, 8); + decorr_left_weight = get_bits(&alac->gb, 8); for (ch = 0; ch < channels; ch++) { - prediction_type[ch] = get_bits(&alac->gb, 4); - prediction_quantitization[ch] = get_bits(&alac->gb, 4); - - ricemodifier[ch] = get_bits(&alac->gb, 3); - predictor_coef_num[ch] = get_bits(&alac->gb, 5); + prediction_type[ch] = get_bits(&alac->gb, 4); + lpc_quant[ch] = get_bits(&alac->gb, 4); + rice_history_mult[ch] = get_bits(&alac->gb, 3); + lpc_order[ch] = get_bits(&alac->gb, 5); /* read the predictor table */ - for (i = 0; i < predictor_coef_num[ch]; i++) - predictor_coef_table[ch][i] = get_sbits(&alac->gb, 16); + for (i = 0; i < lpc_order[ch]; i++) + lpc_coefs[ch][i] = get_sbits(&alac->gb, 16); } if (alac->extra_bits) { @@ -386,11 +376,9 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index, } } for (ch = 0; ch < channels; ch++) { - bastardized_rice_decompress(alac, - alac->predict_error_buffer[ch], - alac->nb_samples, - readsamplesize, - ricemodifier[ch] * alac->rice_history_mult / 4); + rice_decompress(alac, alac->predict_error_buffer[ch], + alac->nb_samples, bps, + rice_history_mult[ch] * alac->rice_history_mult / 4); /* adaptive FIR filter */ if (prediction_type[ch] == 15) { @@ -401,20 +389,16 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index, * However, this prediction type is not currently used by the * reference encoder. */ - predictor_decompress_fir_adapt(alac->predict_error_buffer[ch], - alac->predict_error_buffer[ch], - alac->nb_samples, readsamplesize, - NULL, 31, 0); + lpc_prediction(alac->predict_error_buffer[ch], + alac->predict_error_buffer[ch], + alac->nb_samples, bps, NULL, 31, 0); } else if (prediction_type[ch] > 0) { av_log(avctx, AV_LOG_WARNING, "unknown prediction type: %i\n", prediction_type[ch]); } - predictor_decompress_fir_adapt(alac->predict_error_buffer[ch], - alac->output_samples_buffer[ch], - alac->nb_samples, readsamplesize, - predictor_coef_table[ch], - predictor_coef_num[ch], - prediction_quantitization[ch]); + lpc_prediction(alac->predict_error_buffer[ch], + alac->output_samples_buffer[ch], alac->nb_samples, + bps, lpc_coefs[ch], lpc_order[ch], lpc_quant[ch]); } } else { /* not compressed, easy case */ @@ -424,13 +408,13 @@ static int decode_element(AVCodecContext *avctx, void *data, int ch_index, } } alac->extra_bits = 0; - interlacing_shift = 0; - interlacing_leftweight = 0; + decorr_shift = 0; + decorr_left_weight = 0; } - if (channels == 2 && interlacing_leftweight) { + if (channels == 2 && decorr_left_weight) { decorrelate_stereo(alac->output_samples_buffer, alac->nb_samples, - interlacing_shift, interlacing_leftweight); + decorr_shift, decorr_left_weight); } if (alac->extra_bits) {