X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Falac.c;h=80f6863105755f58abb27e2a5ec4799bded24f1b;hb=4e13e50432bd1c1a89f626f8196b55a0302c8f19;hp=9e77f67457c48b347611a561c3c11722f59311ef;hpb=7a50ec6799b92f0e3681d734aa0769857a16ef87;p=ffmpeg diff --git a/libavcodec/alac.c b/libavcodec/alac.c index 9e77f67457c..80f68631057 100644 --- a/libavcodec/alac.c +++ b/libavcodec/alac.c @@ -45,7 +45,7 @@ * 32bit samplerate */ - +#include "libavutil/audioconvert.h" #include "avcodec.h" #include "get_bits.h" #include "bytestream.h" @@ -53,20 +53,17 @@ #include "mathops.h" #define ALAC_EXTRADATA_SIZE 36 -#define MAX_CHANNELS 2 +#define MAX_CHANNELS 8 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,17 +71,51 @@ typedef struct { uint8_t rice_initial_history; uint8_t rice_limit; - int extra_bits; /**< number of extra bits beyond 16-bit */ - int nb_samples; /**< number of samples in the current frame */ + 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) +enum RawDataBlockType { + /* At the moment, only SCE, CPE, LFE, and END are recognized. */ + TYPE_SCE, + TYPE_CPE, + TYPE_CCE, + TYPE_LFE, + TYPE_DSE, + TYPE_PCE, + TYPE_FIL, + TYPE_END +}; + +static const uint8_t alac_channel_layout_offsets[8][8] = { + { 0 }, + { 0, 1 }, + { 2, 0, 1 }, + { 2, 0, 1, 3 }, + { 2, 0, 1, 3, 4 }, + { 2, 0, 1, 4, 5, 3 }, + { 2, 0, 1, 4, 5, 6, 3 }, + { 2, 6, 7, 0, 1, 4, 5, 3 } +}; + +static const uint16_t alac_channel_layouts[8] = { + AV_CH_LAYOUT_MONO, + AV_CH_LAYOUT_STEREO, + AV_CH_LAYOUT_SURROUND, + AV_CH_LAYOUT_4POINT0, + AV_CH_LAYOUT_5POINT0_BACK, + AV_CH_LAYOUT_5POINT1_BACK, + AV_CH_LAYOUT_6POINT1_BACK, + AV_CH_LAYOUT_7POINT1_WIDE_BACK +}; + +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); @@ -100,29 +131,26 @@ 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++) { - int x, k; + for (i = 0; i < nb_samples; i++) { + int k; + unsigned int x; - /* 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 = decode_scalar(&alac->gb, k, bps); x += sign_modifier; sign_modifier = 0; + output_buffer[i] = (x >> 1) ^ -(x & 1); - output_buffer[output_count] = (x >> 1) ^ -(x & 1); - - /* now update the history */ + /* update the history */ if (x > 0xffff) history = 0xffff; else @@ -130,27 +158,27 @@ 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 */); + /* 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, + memset(&output_buffer[i + 1], 0, block_size * sizeof(*output_buffer)); - output_count += block_size; + i += block_size; } - if (block_size <= 0xffff) sign_modifier = 1; - history = 0; } } @@ -161,93 +189,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 (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++) { - buffer_out[i + 1] = sign_extend(buffer_out[i] + error_buffer[i + 1], - readsamplesize); - } + 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 */ - for (i = predictor_coef_num; i < output_size - 1; i++) { + for (; i < nb_samples; i++) { int j; int val = 0; - int error_val = error_buffer[i + 1]; + int error_val = error_buffer[i]; int error_sign; - int d = buffer_out[i - predictor_coef_num]; + int d = *pred++; - for (j = 0; j < predictor_coef_num; j++) { - val += (buffer_out[i - j] - d) * - predictor_coef_table[j]; - } - - val = (val + (1 << (predictor_quantitization - 1))) >> - predictor_quantitization; + /* 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 + 1] = sign_extend(val, readsamplesize); + buffer_out[i] = 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 = 0; j < lpc_order && error_val * error_sign > 0; j++) { int sign; - val = d - buffer_out[i - j]; + val = d - pred[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) * (j + 1); } } } } -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; @@ -255,118 +271,86 @@ 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) +static int decode_element(AVCodecContext *avctx, void *data, int ch_index, + int channels) { - 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) -{ - const uint8_t *inbuffer = avpkt->data; - int input_buffer_size = avpkt->size; ALACContext *alac = avctx->priv_data; - - int channels; - int hassize; - unsigned int readsamplesize; - int is_compressed; - 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 */ is_compressed = !get_bits1(&alac->gb); - if (hassize) { - /* now read the number of samples as a 32bit integer */ - uint32_t output_samples = get_bits_long(&alac->gb, 32); - if (!output_samples || output_samples > alac->max_samples_per_frame) { - av_log(avctx, AV_LOG_ERROR, "invalid samples per frame: %d\n", - output_samples); - return AVERROR_INVALIDDATA; + 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: %d\n", + output_samples); + return AVERROR_INVALIDDATA; + } + if (!alac->nb_samples) { + /* get output buffer */ + alac->frame.nb_samples = output_samples; + if ((ret = avctx->get_buffer(avctx, &alac->frame)) < 0) { + av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); + return ret; } - alac->nb_samples = output_samples; - } else - alac->nb_samples = alac->max_samples_per_frame; - - /* get output buffer */ - alac->frame.nb_samples = alac->nb_samples; - if ((ret = avctx->get_buffer(avctx, &alac->frame)) < 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: %u != %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 *)alac->frame.extended_data[ch_index + ch]; } if (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]; + 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); - - 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] = (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) { @@ -376,11 +360,9 @@ static int alac_decode_frame(AVCodecContext *avctx, void *data, } } 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) { @@ -391,79 +373,111 @@ 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], - 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 */ 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) { + 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) { append_extra_bits(alac->output_samples_buffer, alac->extra_bits_buffer, - alac->extra_bits, alac->channels, alac->nb_samples); + 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], - alac->nb_samples); - } else { - int16_t *outbuffer = (int16_t *)alac->frame.data[0]; - for (i = 0; i < alac->nb_samples; i++) { - outbuffer[i] = alac->output_samples_buffer[0][i]; - } - } + case 16: { + for (ch = 0; ch < channels; ch++) { + int16_t *outbuffer = (int16_t *)alac->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], - alac->nb_samples); - } else { - int32_t *outbuffer = (int32_t *)alac->frame.data[0]; + case 24: { + for (ch = 0; ch < channels; ch++) { for (i = 0; i < alac->nb_samples; i++) - outbuffer[i] = alac->output_samples_buffer[0][i] << 8; - } + 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; +} + +static int alac_decode_frame(AVCodecContext *avctx, void *data, + int *got_frame_ptr, AVPacket *avpkt) +{ + ALACContext *alac = avctx->priv_data; + enum RawDataBlockType 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) { + av_log(avctx, AV_LOG_ERROR, "invalid element channel count\n"); + return AVERROR_INVALIDDATA; + } + + ret = decode_element(avctx, data, + 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; + } + + 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; *(AVFrame *)data = alac->frame; - return input_buffer_size; + return avpkt->size; } static av_cold int alac_decode_close(AVCodecContext *avctx) @@ -471,9 +485,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]); } @@ -483,14 +498,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); @@ -511,9 +528,9 @@ 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){ - av_log(alac->avctx, AV_LOG_ERROR, - "max_samples_per_frame too large\n"); + if (!alac->max_samples_per_frame || alac->max_samples_per_frame > INT_MAX) { + av_log(alac->avctx, AV_LOG_ERROR, "max samples per frame invalid: %u\n", + alac->max_samples_per_frame); return AVERROR_INVALIDDATA; } bytestream2_skipu(&gb, 1); // compatible version @@ -548,14 +565,16 @@ 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); 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"); @@ -571,6 +590,7 @@ static av_cold int alac_decode_init(AVCodecContext * avctx) avctx->channels); return AVERROR_PATCHWELCOME; } + avctx->channel_layout = alac_channel_layouts[alac->channels - 1]; if ((ret = allocate_buffers(alac)) < 0) { av_log(avctx, AV_LOG_ERROR, "Error allocating buffers\n"); @@ -586,7 +606,7 @@ static av_cold int alac_decode_init(AVCodecContext * avctx) AVCodec ff_alac_decoder = { .name = "alac", .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,