* ALAC (Apple Lossless Audio Codec) decoder
* Copyright (c) 2005 David Hammerton
*
- * This file is part of Libav.
+ * This file is part of FFmpeg.
*
- * Libav is free software; you can redistribute it and/or
+ * FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
- * Libav is distributed in the hope that it will be useful,
+ * FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
int isnotcompressed;
uint8_t interlacing_shift;
uint8_t interlacing_leftweight;
-
- /* short-circuit null buffers */
- if (!inbuffer || !input_buffer_size)
- return -1;
+ int i, ch;
init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);
int prediction_type[MAX_CHANNELS];
int prediction_quantitization[MAX_CHANNELS];
int ricemodifier[MAX_CHANNELS];
- int i, chan;
interlacing_shift = get_bits(&alac->gb, 8);
interlacing_leftweight = get_bits(&alac->gb, 8);
- for (chan = 0; chan < channels; chan++) {
- prediction_type[chan] = get_bits(&alac->gb, 4);
- prediction_quantitization[chan] = get_bits(&alac->gb, 4);
+ for (ch = 0; ch < channels; ch++) {
+ prediction_type[ch] = get_bits(&alac->gb, 4);
+ prediction_quantitization[ch] = get_bits(&alac->gb, 4);
- ricemodifier[chan] = get_bits(&alac->gb, 3);
- predictor_coef_num[chan] = get_bits(&alac->gb, 5);
+ ricemodifier[ch] = get_bits(&alac->gb, 3);
+ predictor_coef_num[ch] = get_bits(&alac->gb, 5);
/* read the predictor table */
- for (i = 0; i < predictor_coef_num[chan]; i++)
- predictor_coef_table[chan][i] = (int16_t)get_bits(&alac->gb, 16);
+ for (i = 0; i < predictor_coef_num[ch]; i++)
+ predictor_coef_table[ch][i] = (int16_t)get_bits(&alac->gb, 16);
}
if (alac->extra_bits) {
- int i, ch;
for (i = 0; i < outputsamples; i++) {
for (ch = 0; ch < channels; ch++)
alac->extra_bits_buffer[ch][i] = get_bits(&alac->gb, alac->extra_bits);
}
}
- for (chan = 0; chan < channels; chan++) {
+ for (ch = 0; ch < channels; ch++) {
bastardized_rice_decompress(alac,
- alac->predicterror_buffer[chan],
+ alac->predicterror_buffer[ch],
outputsamples,
readsamplesize,
alac->setinfo_rice_initialhistory,
alac->setinfo_rice_kmodifier,
- ricemodifier[chan] * alac->setinfo_rice_historymult / 4,
+ ricemodifier[ch] * alac->setinfo_rice_historymult / 4,
(1 << alac->setinfo_rice_kmodifier) - 1);
- if (prediction_type[chan] == 0) {
+ if (prediction_type[ch] == 0) {
/* adaptive fir */
- predictor_decompress_fir_adapt(alac->predicterror_buffer[chan],
- alac->outputsamples_buffer[chan],
+ predictor_decompress_fir_adapt(alac->predicterror_buffer[ch],
+ alac->outputsamples_buffer[ch],
outputsamples,
readsamplesize,
- predictor_coef_table[chan],
- predictor_coef_num[chan],
- prediction_quantitization[chan]);
+ predictor_coef_table[ch],
+ predictor_coef_num[ch],
+ prediction_quantitization[ch]);
} else {
- av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type[chan]);
+ av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type[ch]);
/* I think the only other prediction type (or perhaps this is
* just a boolean?) runs adaptive fir twice.. like:
* predictor_decompress_fir_adapt(predictor_error, tempout, ...)
}
} else {
/* not compressed, easy case */
- int i, chan;
- if (alac->setinfo_sample_size <= 16) {
- for (i = 0; i < outputsamples; i++)
- for (chan = 0; chan < channels; chan++) {
- int32_t audiobits;
-
- audiobits = get_sbits_long(&alac->gb, alac->setinfo_sample_size);
-
- alac->outputsamples_buffer[chan][i] = audiobits;
- }
- } else {
- for (i = 0; i < outputsamples; i++) {
- for (chan = 0; chan < channels; chan++) {
- alac->outputsamples_buffer[chan][i] = get_bits(&alac->gb,
- alac->setinfo_sample_size);
- alac->outputsamples_buffer[chan][i] = sign_extend(alac->outputsamples_buffer[chan][i],
- alac->setinfo_sample_size);
- }
+ for (i = 0; i < outputsamples; i++) {
+ for (ch = 0; ch < channels; ch++) {
+ alac->outputsamples_buffer[ch][i] = get_sbits_long(&alac->gb,
+ alac->setinfo_sample_size);
}
}
alac->extra_bits = 0;
interleave_stereo_16(alac->outputsamples_buffer, outbuffer,
outputsamples);
} else {
- int i;
for (i = 0; i < outputsamples; i++) {
((int16_t*)outbuffer)[i] = alac->outputsamples_buffer[0][i];
}
interleave_stereo_24(alac->outputsamples_buffer, outbuffer,
outputsamples);
} else {
- int i;
for (i = 0; i < outputsamples; i++)
((int32_t *)outbuffer)[i] = alac->outputsamples_buffer[0][i] << 8;
}
{
ALACContext *alac = avctx->priv_data;
- int chan;
- for (chan = 0; chan < alac->numchannels; chan++) {
- av_freep(&alac->predicterror_buffer[chan]);
- av_freep(&alac->outputsamples_buffer[chan]);
- av_freep(&alac->extra_bits_buffer[chan]);
+ int ch;
+ for (ch = 0; ch < alac->numchannels; ch++) {
+ av_freep(&alac->predicterror_buffer[ch]);
+ av_freep(&alac->outputsamples_buffer[ch]);
+ av_freep(&alac->extra_bits_buffer[ch]);
}
return 0;
static int allocate_buffers(ALACContext *alac)
{
- int chan;
- for (chan = 0; chan < alac->numchannels; chan++) {
- alac->predicterror_buffer[chan] =
- av_malloc(alac->setinfo_max_samples_per_frame * 4);
+ int ch;
+ for (ch = 0; ch < alac->numchannels; ch++) {
+ int buf_size = alac->setinfo_max_samples_per_frame * sizeof(int32_t);
- alac->outputsamples_buffer[chan] =
- av_malloc(alac->setinfo_max_samples_per_frame * 4);
+ FF_ALLOC_OR_GOTO(alac->avctx, alac->predicterror_buffer[ch],
+ buf_size, buf_alloc_fail);
- alac->extra_bits_buffer[chan] = av_malloc(alac->setinfo_max_samples_per_frame * 4);
+ FF_ALLOC_OR_GOTO(alac->avctx, alac->outputsamples_buffer[ch],
+ buf_size, buf_alloc_fail);
- if (!alac->predicterror_buffer[chan] ||
- !alac->outputsamples_buffer[chan] ||
- !alac->extra_bits_buffer[chan]) {
- alac_decode_close(alac->avctx);
- return AVERROR(ENOMEM);
- }
+ FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch],
+ buf_size, buf_alloc_fail);
}
return 0;
+buf_alloc_fail:
+ alac_decode_close(alac->avctx);
+ return AVERROR(ENOMEM);
}
static int alac_set_info(ALACContext *alac)
break;
case 24: avctx->sample_fmt = AV_SAMPLE_FMT_S32;
break;
- default: av_log(avctx, AV_LOG_ERROR, "Sample depth %d is not supported.\n",
- alac->setinfo_sample_size);
- return -1;
+ default: av_log_ask_for_sample(avctx, "Sample depth %d is not supported.\n",
+ alac->setinfo_sample_size);
+ return AVERROR_PATCHWELCOME;
}
if (alac->numchannels < 1) {
projects / ffmpeg / blobdiff