X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Falac.c;h=5272f8416c68e5dd22b74203f3e60e59f93f611a;hb=a536a4e4bc52d05f59869761337452fb1f1977f6;hp=84f7e42373da4cf57daa19cd676cfb03bf9bd04b;hpb=a06fdadd97778fe50713c2762714cbd8b0eb81b6;p=ffmpeg diff --git a/libavcodec/alac.c b/libavcodec/alac.c index 84f7e42373d..5272f8416c6 100644 --- a/libavcodec/alac.c +++ b/libavcodec/alac.c @@ -45,28 +45,27 @@ * 32bit samplerate */ +#include +#include "libavutil/channel_layout.h" #include "avcodec.h" #include "get_bits.h" #include "bytestream.h" +#include "internal.h" #include "unary.h" #include "mathops.h" +#include "alac_data.h" #define ALAC_EXTRADATA_SIZE 36 -#define MAX_CHANNELS 2 typedef struct { - AVCodecContext *avctx; - AVFrame frame; GetBitContext gb; - int channels; - /* buffers */ - int32_t *predict_error_buffer[MAX_CHANNELS]; - int32_t *output_samples_buffer[MAX_CHANNELS]; - int32_t *extra_bits_buffer[MAX_CHANNELS]; + int32_t *predict_error_buffer[2]; + int32_t *output_samples_buffer[2]; + int32_t *extra_bits_buffer[2]; uint32_t max_samples_per_frame; uint8_t sample_size; @@ -74,16 +73,17 @@ typedef struct { uint8_t rice_initial_history; uint8_t rice_limit; - int extra_bits; /**< number of extra bits beyond 16-bit */ + int extra_bits; /**< number of extra bits beyond 16-bit */ + int nb_samples; /**< number of samples in the current frame */ } ALACContext; -static inline int decode_scalar(GetBitContext *gb, int k, int readsamplesize) +static inline unsigned int decode_scalar(GetBitContext *gb, int k, int bps) { - int x = get_unary_0_9(gb); + unsigned int x = get_unary_0_9(gb); if (x > 8) { /* RICE THRESHOLD */ /* use alternative encoding */ - x = get_bits(gb, readsamplesize); + x = get_bits_long(gb, bps); } else if (k != 1) { int extrabits = show_bits(gb, k); @@ -99,68 +99,54 @@ static inline int decode_scalar(GetBitContext *gb, int k, int readsamplesize) 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++) { - int32_t x; - int32_t x_modified; - int32_t final_val; + for (i = 0; i < nb_samples; i++) { + int k; + unsigned int x; - /* standard rice encoding */ - int k; /* size of extra bits */ - - /* read k, that is bits as is */ + /* calculate rice param and decode next value */ k = av_log2((history >> 9) + 3); k = FFMIN(k, alac->rice_limit); - x = decode_scalar(&alac->gb, k, readsamplesize); - - x_modified = sign_modifier + x; - final_val = (x_modified + 1) / 2; - if (x_modified & 1) final_val *= -1; - - output_buffer[output_count] = final_val; - + x = decode_scalar(&alac->gb, k, bps); + x += sign_modifier; sign_modifier = 0; + output_buffer[i] = (x >> 1) ^ -(x & 1); - /* now update the history */ - history += x_modified * rice_history_mult - - ((history * rice_history_mult) >> 9); - - if (x_modified > 0xffff) + /* update the history */ + if (x > 0xffff) history = 0xffff; + else + history += x * rice_history_mult - + ((history * rice_history_mult) >> 9); /* special case: there may be compressed blocks of 0 */ - if ((history < 128) && (output_count+1 < output_size)) { - int k; - unsigned int block_size; + if ((history < 128) && (i + 1 < nb_samples)) { + int block_size; - sign_modifier = 1; - - k = 7 - av_log2(history) + ((history + 16) >> 6 /* / 64 */); + /* calculate rice param and decode block size */ + k = 7 - av_log2(history) + ((history + 16) >> 6); k = FFMIN(k, alac->rice_limit); - 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, block_size * 4); - output_count += block_size; + memset(&output_buffer[i + 1], 0, + block_size * sizeof(*output_buffer)); + i += block_size; } - - if (block_size > 0xffff) - sign_modifier = 0; - + if (block_size <= 0xffff) + sign_modifier = 1; history = 0; } } @@ -171,127 +157,81 @@ 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; + int32_t *pred = buffer_out; /* first sample always copies */ *buffer_out = *error_buffer; - if (!predictor_coef_num) { - if (output_size <= 1) - return; + if (nb_samples <= 1) + return; - memcpy(buffer_out+1, error_buffer+1, (output_size-1) * 4); + if (!lpc_order) { + memcpy(&buffer_out[1], &error_buffer[1], + (nb_samples - 1) * sizeof(*buffer_out)); return; } - if (predictor_coef_num == 31) { + if (lpc_order == 31) { /* simple 1st-order prediction */ - if (output_size <= 1) - return; - for (i = 0; i < output_size - 1; i++) { - int32_t prev_value; - int32_t error_value; - - prev_value = buffer_out[i]; - error_value = error_buffer[i+1]; - buffer_out[i+1] = - sign_extend((prev_value + error_value), readsamplesize); + for (i = 1; i < nb_samples; i++) { + buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i], + bps); } return; } /* read warm-up samples */ - if (predictor_coef_num > 0) - for (i = 0; i < predictor_coef_num; i++) { - int32_t val; - - val = buffer_out[i] + error_buffer[i+1]; - val = sign_extend(val, readsamplesize); - buffer_out[i+1] = val; - } + for (i = 1; i <= lpc_order; i++) + buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i], bps); /* NOTE: 4 and 8 are very common cases that could be optimized. */ - /* general case */ - if (predictor_coef_num > 0) { - for (i = predictor_coef_num + 1; i < output_size; i++) { - int j; - int sum = 0; - int outval; - int error_val = error_buffer[i]; - - for (j = 0; j < predictor_coef_num; j++) { - sum += (buffer_out[predictor_coef_num-j] - buffer_out[0]) * - predictor_coef_table[j]; + for (; i < nb_samples; i++) { + int j; + int val = 0; + int error_val = error_buffer[i]; + int error_sign; + int d = *pred++; + + /* LPC prediction */ + for (j = 0; j < lpc_order; j++) + val += (pred[j] - d) * lpc_coefs[j]; + val = (val + (1 << (lpc_quant - 1))) >> lpc_quant; + val += d + error_val; + buffer_out[i] = sign_extend(val, bps); + + /* adapt LPC coefficients */ + error_sign = sign_only(error_val); + if (error_sign) { + for (j = 0; j < lpc_order && error_val * error_sign > 0; j++) { + int sign; + val = d - pred[j]; + sign = sign_only(val) * error_sign; + lpc_coefs[j] -= sign; + val *= sign; + error_val -= (val >> lpc_quant) * (j + 1); } - - outval = (1 << (predictor_quantitization-1)) + sum; - outval = outval >> predictor_quantitization; - outval = outval + buffer_out[0] + error_val; - outval = sign_extend(outval, readsamplesize); - - buffer_out[predictor_coef_num+1] = outval; - - if (error_val > 0) { - int predictor_num = predictor_coef_num - 1; - - while (predictor_num >= 0 && error_val > 0) { - int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num]; - int sign = sign_only(val); - - predictor_coef_table[predictor_num] -= sign; - - val *= sign; /* absolute value */ - - error_val -= ((val >> predictor_quantitization) * - (predictor_coef_num - predictor_num)); - - predictor_num--; - } - } else if (error_val < 0) { - int predictor_num = predictor_coef_num - 1; - - while (predictor_num >= 0 && error_val < 0) { - int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num]; - int sign = - sign_only(val); - - predictor_coef_table[predictor_num] -= sign; - - val *= sign; /* neg value */ - - error_val -= ((val >> predictor_quantitization) * - (predictor_coef_num - predictor_num)); - - predictor_num--; - } - } - - buffer_out++; } } } -static void decorrelate_stereo(int32_t *buffer[MAX_CHANNELS], - int numsamples, uint8_t interlacing_shift, - uint8_t interlacing_leftweight) +static void decorrelate_stereo(int32_t *buffer[2], int nb_samples, + int decorr_shift, int 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; @@ -299,137 +239,101 @@ static void decorrelate_stereo(int32_t *buffer[MAX_CHANNELS], } } -static void append_extra_bits(int32_t *buffer[MAX_CHANNELS], - int32_t *extra_bits_buffer[MAX_CHANNELS], - int extra_bits, int numchannels, int numsamples) +static void append_extra_bits(int32_t *buffer[2], int32_t *extra_bits_buffer[2], + 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]; } -static void interleave_stereo_16(int32_t *buffer[MAX_CHANNELS], - int16_t *buffer_out, int numsamples) -{ - int i; - - for (i = 0; i < numsamples; i++) { - *buffer_out++ = buffer[0][i]; - *buffer_out++ = buffer[1][i]; - } -} - -static void interleave_stereo_24(int32_t *buffer[MAX_CHANNELS], - int32_t *buffer_out, int numsamples) -{ - int i; - - for (i = 0; i < numsamples; i++) { - *buffer_out++ = buffer[0][i] << 8; - *buffer_out++ = buffer[1][i] << 8; - } -} - -static int alac_decode_frame(AVCodecContext *avctx, void *data, - int *got_frame_ptr, AVPacket *avpkt) +static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index, + int channels) { - const uint8_t *inbuffer = avpkt->data; - int input_buffer_size = avpkt->size; ALACContext *alac = avctx->priv_data; - - int channels; - unsigned int outputsamples; - int hassize; - unsigned int readsamplesize; - int isnotcompressed; - uint8_t interlacing_shift; - uint8_t interlacing_leftweight; - int i, ch, ret; - - init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8); - - channels = get_bits(&alac->gb, 3) + 1; - if (channels != avctx->channels) { - av_log(avctx, AV_LOG_ERROR, "frame header channel count mismatch\n"); - return AVERROR_INVALIDDATA; - } + int has_size, bps, is_compressed, decorr_shift, decorr_left_weight, ret; + uint32_t output_samples; + int i, ch; skip_bits(&alac->gb, 4); /* element instance tag */ 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; + 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 */ - isnotcompressed = get_bits1(&alac->gb); - - if (hassize) { - /* now read the number of samples as a 32bit integer */ - outputsamples = get_bits_long(&alac->gb, 32); - if (outputsamples > alac->max_samples_per_frame) { - av_log(avctx, AV_LOG_ERROR, "outputsamples %d > %d\n", - outputsamples, alac->max_samples_per_frame); - return -1; - } - } else - outputsamples = alac->max_samples_per_frame; - - /* get output buffer */ - if (outputsamples > INT32_MAX) { - av_log(avctx, AV_LOG_ERROR, "unsupported block size: %u\n", outputsamples); + is_compressed = !get_bits1(&alac->gb); + + if (has_size) + output_samples = get_bits_long(&alac->gb, 32); + else + output_samples = alac->max_samples_per_frame; + if (!output_samples || output_samples > alac->max_samples_per_frame) { + av_log(avctx, AV_LOG_ERROR, "invalid samples per frame: %"PRIu32"\n", + output_samples); return AVERROR_INVALIDDATA; } - alac->frame.nb_samples = outputsamples; - if ((ret = avctx->get_buffer(avctx, &alac->frame)) < 0) { - av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); - return ret; + if (!alac->nb_samples) { + /* get output buffer */ + frame->nb_samples = output_samples; + if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) { + av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); + return ret; + } + } else if (output_samples != alac->nb_samples) { + av_log(avctx, AV_LOG_ERROR, "sample count mismatch: %"PRIu32" != %d\n", + output_samples, alac->nb_samples); + return AVERROR_INVALIDDATA; } - - readsamplesize = alac->sample_size - alac->extra_bits + channels - 1; - if (readsamplesize > MIN_CACHE_BITS) { - av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize); - return -1; + alac->nb_samples = output_samples; + if (alac->sample_size > 16) { + for (ch = 0; ch < channels; ch++) + alac->output_samples_buffer[ch] = (int32_t *)frame->extended_data[ch_index + ch]; } - if (!isnotcompressed) { - /* so it is compressed */ - int16_t predictor_coef_table[MAX_CHANNELS][32]; - int predictor_coef_num[MAX_CHANNELS]; - int prediction_type[MAX_CHANNELS]; - int prediction_quantitization[MAX_CHANNELS]; - int ricemodifier[MAX_CHANNELS]; + if (is_compressed) { + int16_t lpc_coefs[2][32]; + int lpc_order[2]; + int prediction_type[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); + 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); - ricemodifier[ch] = get_bits(&alac->gb, 3); - predictor_coef_num[ch] = get_bits(&alac->gb, 5); + if (lpc_order[ch] >= alac->max_samples_per_frame) + return AVERROR_INVALIDDATA; /* read the predictor table */ - for (i = 0; i < predictor_coef_num[ch]; i++) - predictor_coef_table[ch][i] = (int16_t)get_bits(&alac->gb, 16); + for (i = lpc_order[ch] - 1; i >= 0; i--) + lpc_coefs[ch][i] = get_sbits(&alac->gb, 16); } if (alac->extra_bits) { - for (i = 0; i < outputsamples; i++) { + for (i = 0; i < alac->nb_samples; i++) { for (ch = 0; ch < channels; ch++) alac->extra_bits_buffer[ch][i] = get_bits(&alac->gb, alac->extra_bits); } } for (ch = 0; ch < channels; ch++) { - bastardized_rice_decompress(alac, - alac->predict_error_buffer[ch], - outputsamples, - 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) { @@ -440,77 +344,112 @@ static int alac_decode_frame(AVCodecContext *avctx, void *data, * 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], - outputsamples, 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], - outputsamples, 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 */ - for (i = 0; i < outputsamples; i++) { + for (i = 0; i < alac->nb_samples; i++) { for (ch = 0; ch < channels; ch++) { - alac->output_samples_buffer[ch][i] = get_sbits_long(&alac->gb, - alac->sample_size); + alac->output_samples_buffer[ch][i] = + get_sbits_long(&alac->gb, alac->sample_size); } } - alac->extra_bits = 0; - interlacing_shift = 0; - interlacing_leftweight = 0; + alac->extra_bits = 0; + decorr_shift = 0; + decorr_left_weight = 0; } - if (get_bits(&alac->gb, 3) != 7) - av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n"); - if (channels == 2 && interlacing_leftweight) { - decorrelate_stereo(alac->output_samples_buffer, outputsamples, - interlacing_shift, interlacing_leftweight); + if (channels == 2 && decorr_left_weight) { + decorrelate_stereo(alac->output_samples_buffer, alac->nb_samples, + decorr_shift, decorr_left_weight); } if (alac->extra_bits) { append_extra_bits(alac->output_samples_buffer, alac->extra_bits_buffer, - alac->extra_bits, alac->channels, outputsamples); + alac->extra_bits, channels, alac->nb_samples); } switch(alac->sample_size) { - case 16: - if (channels == 2) { - interleave_stereo_16(alac->output_samples_buffer, - (int16_t *)alac->frame.data[0], outputsamples); - } else { - int16_t *outbuffer = (int16_t *)alac->frame.data[0]; - for (i = 0; i < outputsamples; i++) { - outbuffer[i] = alac->output_samples_buffer[0][i]; - } - } + case 16: { + for (ch = 0; ch < channels; ch++) { + int16_t *outbuffer = (int16_t *)frame->extended_data[ch_index + ch]; + for (i = 0; i < alac->nb_samples; i++) + *outbuffer++ = alac->output_samples_buffer[ch][i]; + }} break; - case 24: - if (channels == 2) { - interleave_stereo_24(alac->output_samples_buffer, - (int32_t *)alac->frame.data[0], outputsamples); - } else { - int32_t *outbuffer = (int32_t *)alac->frame.data[0]; - for (i = 0; i < outputsamples; i++) - outbuffer[i] = alac->output_samples_buffer[0][i] << 8; - } + case 24: { + for (ch = 0; ch < channels; ch++) { + for (i = 0; i < alac->nb_samples; i++) + alac->output_samples_buffer[ch][i] <<= 8; + }} break; } - if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8) - av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb)); + return 0; +} - *got_frame_ptr = 1; - *(AVFrame *)data = alac->frame; +static int alac_decode_frame(AVCodecContext *avctx, void *data, + int *got_frame_ptr, AVPacket *avpkt) +{ + ALACContext *alac = avctx->priv_data; + AVFrame *frame = data; + enum AlacRawDataBlockType element; + int channels; + int ch, ret, got_end; + + init_get_bits(&alac->gb, avpkt->data, avpkt->size * 8); + + got_end = 0; + alac->nb_samples = 0; + ch = 0; + while (get_bits_left(&alac->gb) >= 3) { + element = get_bits(&alac->gb, 3); + if (element == TYPE_END) { + got_end = 1; + break; + } + if (element > TYPE_CPE && element != TYPE_LFE) { + av_log(avctx, AV_LOG_ERROR, "syntax element unsupported: %d", element); + return AVERROR_PATCHWELCOME; + } + + channels = (element == TYPE_CPE) ? 2 : 1; + if (ch + channels > alac->channels || + ff_alac_channel_layout_offsets[alac->channels - 1][ch] + channels > alac->channels) { + av_log(avctx, AV_LOG_ERROR, "invalid element channel count\n"); + return AVERROR_INVALIDDATA; + } + + ret = decode_element(avctx, frame, + ff_alac_channel_layout_offsets[alac->channels - 1][ch], + channels); + if (ret < 0 && get_bits_left(&alac->gb)) + return ret; + + ch += channels; + } + if (!got_end) { + av_log(avctx, AV_LOG_ERROR, "no end tag found. incomplete packet.\n"); + return AVERROR_INVALIDDATA; + } - return input_buffer_size; + if (avpkt->size * 8 - get_bits_count(&alac->gb) > 8) { + av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", + avpkt->size * 8 - get_bits_count(&alac->gb)); + } + + *got_frame_ptr = 1; + + return avpkt->size; } static av_cold int alac_decode_close(AVCodecContext *avctx) @@ -518,9 +457,10 @@ static av_cold int alac_decode_close(AVCodecContext *avctx) ALACContext *alac = avctx->priv_data; int ch; - for (ch = 0; ch < alac->channels; ch++) { + for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) { av_freep(&alac->predict_error_buffer[ch]); - av_freep(&alac->output_samples_buffer[ch]); + if (alac->sample_size == 16) + av_freep(&alac->output_samples_buffer[ch]); av_freep(&alac->extra_bits_buffer[ch]); } @@ -530,14 +470,16 @@ static av_cold int alac_decode_close(AVCodecContext *avctx) static int allocate_buffers(ALACContext *alac) { int ch; - for (ch = 0; ch < alac->channels; ch++) { - int buf_size = alac->max_samples_per_frame * sizeof(int32_t); + int buf_size = alac->max_samples_per_frame * sizeof(int32_t); + for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) { FF_ALLOC_OR_GOTO(alac->avctx, alac->predict_error_buffer[ch], buf_size, buf_alloc_fail); - FF_ALLOC_OR_GOTO(alac->avctx, alac->output_samples_buffer[ch], - buf_size, buf_alloc_fail); + if (alac->sample_size == 16) { + FF_ALLOC_OR_GOTO(alac->avctx, alac->output_samples_buffer[ch], + buf_size, buf_alloc_fail); + } FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch], buf_size, buf_alloc_fail); @@ -558,9 +500,11 @@ static int alac_set_info(ALACContext *alac) bytestream2_skipu(&gb, 12); // size:4, alac:4, version:4 alac->max_samples_per_frame = bytestream2_get_be32u(&gb); - if (alac->max_samples_per_frame >= UINT_MAX/4){ + if (!alac->max_samples_per_frame || + alac->max_samples_per_frame > INT_MAX / sizeof(int32_t)) { av_log(alac->avctx, AV_LOG_ERROR, - "max_samples_per_frame too large\n"); + "max samples per frame invalid: %"PRIu32"\n", + alac->max_samples_per_frame); return AVERROR_INVALIDDATA; } bytestream2_skipu(&gb, 1); // compatible version @@ -584,10 +528,9 @@ static av_cold int alac_decode_init(AVCodecContext * avctx) alac->avctx = avctx; /* initialize from the extradata */ - if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) { - av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n", - ALAC_EXTRADATA_SIZE); - return -1; + if (alac->avctx->extradata_size < ALAC_EXTRADATA_SIZE) { + av_log(avctx, AV_LOG_ERROR, "alac: extradata is too small\n"); + return AVERROR_INVALIDDATA; } if (alac_set_info(alac)) { av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n"); @@ -595,49 +538,48 @@ static av_cold int alac_decode_init(AVCodecContext * avctx) } switch (alac->sample_size) { - case 16: avctx->sample_fmt = AV_SAMPLE_FMT_S16; + case 16: avctx->sample_fmt = AV_SAMPLE_FMT_S16P; break; - case 24: avctx->sample_fmt = AV_SAMPLE_FMT_S32; + case 24: + case 32: avctx->sample_fmt = AV_SAMPLE_FMT_S32P; break; - default: av_log_ask_for_sample(avctx, "Sample depth %d is not supported.\n", - alac->sample_size); + default: avpriv_request_sample(avctx, "Sample depth %d", alac->sample_size); return AVERROR_PATCHWELCOME; } + avctx->bits_per_raw_sample = alac->sample_size; if (alac->channels < 1) { av_log(avctx, AV_LOG_WARNING, "Invalid channel count\n"); alac->channels = avctx->channels; } else { - if (alac->channels > MAX_CHANNELS) + if (alac->channels > ALAC_MAX_CHANNELS) alac->channels = avctx->channels; else avctx->channels = alac->channels; } - if (avctx->channels > MAX_CHANNELS) { + if (avctx->channels > ALAC_MAX_CHANNELS) { av_log(avctx, AV_LOG_ERROR, "Unsupported channel count: %d\n", avctx->channels); return AVERROR_PATCHWELCOME; } + avctx->channel_layout = ff_alac_channel_layouts[alac->channels - 1]; if ((ret = allocate_buffers(alac)) < 0) { av_log(avctx, AV_LOG_ERROR, "Error allocating buffers\n"); return ret; } - avcodec_get_frame_defaults(&alac->frame); - avctx->coded_frame = &alac->frame; - return 0; } AVCodec ff_alac_decoder = { .name = "alac", + .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"), .type = AVMEDIA_TYPE_AUDIO, - .id = CODEC_ID_ALAC, + .id = AV_CODEC_ID_ALAC, .priv_data_size = sizeof(ALACContext), .init = alac_decode_init, .close = alac_decode_close, .decode = alac_decode_frame, .capabilities = CODEC_CAP_DR1, - .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"), };