* MPEG-4 ALS decoder
* Copyright (c) 2009 Thilo Borgmann <thilo.borgmann _at_ googlemail.com>
*
- * 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
*/
if (get_bits_left(&gb) < 32)
return -1;
- if (avctx->err_recognition & AV_EF_CRCCHECK) {
+ if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
ctx->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);
ctx->crc = 0xFFFFFFFF;
ctx->crc_org = ~get_bits_long(&gb, 32);
for (k = 1; k < sub_blocks; k++)
s[k] = s[k - 1] + decode_rice(gb, 0);
}
+ for (k = 0; k < sub_blocks; k++)
+ if (s[k] > 32) {
+ av_log(avctx, AV_LOG_ERROR, "k invalid for rice code.\n");
+ return -1;
+ }
if (get_bits1(gb))
*bd->shift_lsbs = get_bits(gb, 4) + 1;
int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,
2, sconf->max_order + 1));
*bd->opt_order = get_bits(gb, opt_order_length);
+ if (*bd->opt_order > sconf->max_order) {
+ *bd->opt_order = sconf->max_order;
+ av_log(avctx, AV_LOG_ERROR, "Predictor order too large!\n");
+ return -1;
+ }
} else {
*bd->opt_order = sconf->max_order;
}
int rice_param = parcor_rice_table[sconf->coef_table][k][1];
int offset = parcor_rice_table[sconf->coef_table][k][0];
quant_cof[k] = decode_rice(gb, rice_param) + offset;
+ if (quant_cof[k] < -64 || quant_cof[k] > 63) {
+ av_log(avctx, AV_LOG_ERROR, "Quantization coefficient %d is out of range!\n", quant_cof[k]);
+ return AVERROR_INVALIDDATA;
+ }
}
// read coefficients 20 to 126
bd->ltp_gain[0] = decode_rice(gb, 1) << 3;
bd->ltp_gain[1] = decode_rice(gb, 2) << 3;
- r = get_unary(gb, 0, 4);
+ r = get_unary(gb, 0, 3);
c = get_bits(gb, 2);
bd->ltp_gain[2] = ltp_gain_values[r][c];
int delta[8];
unsigned int k [8];
unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5);
- unsigned int i;
+ unsigned int i = start;
// read most significant bits
unsigned int high;
current_res = bd->raw_samples + start;
- for (sb = 0; sb < sub_blocks; sb++) {
+ for (sb = 0; sb < sub_blocks; sb++, i = 0) {
k [sb] = s[sb] > b ? s[sb] - b : 0;
delta[sb] = 5 - s[sb] + k[sb];
- ff_bgmc_decode(gb, sb_length, current_res,
+ ff_bgmc_decode(gb, sb_length - i, current_res,
delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
- current_res += sb_length;
+ current_res += sb_length - i;
}
ff_bgmc_decode_end(gb);
{
unsigned int count = 0;
- for (; b < b_max; b++)
- count += div_blocks[b];
+ while (b < b_max)
+ count += div_blocks[b++];
if (count)
memset(buf, 0, sizeof(*buf) * count);
// reconstruct joint-stereo blocks
if (bd[0].js_blocks) {
if (bd[1].js_blocks)
- av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair!\n");
+ av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair.\n");
for (s = 0; s < div_blocks[b]; s++)
bd[0].raw_samples[s] = bd[1].raw_samples[s] - bd[0].raw_samples[s];
}
if (dep == channels) {
- av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation!\n");
+ av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation.\n");
return -1;
}
bd.raw_samples = ctx->raw_samples[c] + offset;
bd.raw_other = NULL;
- read_block(ctx, &bd);
- if (read_channel_data(ctx, ctx->chan_data[c], c))
+ if (read_block(ctx, &bd) || read_channel_data(ctx, ctx->chan_data[c], c))
return -1;
}
bd.lpc_cof = ctx->lpc_cof[c];
bd.quant_cof = ctx->quant_cof[c];
bd.raw_samples = ctx->raw_samples[c] + offset;
- decode_block(ctx, &bd);
+ if (decode_block(ctx, &bd))
+ return -1;
}
memset(reverted_channels, 0, avctx->channels * sizeof(*reverted_channels));
ctx->cur_frame_length = sconf->frame_length;
// decode the frame data
- if ((invalid_frame = read_frame_data(ctx, ra_frame) < 0))
+ if ((invalid_frame = read_frame_data(ctx, ra_frame)) < 0)
av_log(ctx->avctx, AV_LOG_WARNING,
"Reading frame data failed. Skipping RA unit.\n");
}
// update CRC
- if (sconf->crc_enabled && (avctx->err_recognition & AV_EF_CRCCHECK)) {
+ if (sconf->crc_enabled && (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) {
int swap = HAVE_BIGENDIAN != sconf->msb_first;
if (ctx->avctx->bits_per_raw_sample == 24) {
// check CRC sums if this is the last frame
if (ctx->cur_frame_length != sconf->frame_length &&
ctx->crc_org != ctx->crc) {
- av_log(avctx, AV_LOG_ERROR, "CRC error.\n");
+ av_log(avctx, AV_LOG_ERROR, "CRC error!\n");
}
}
ctx->avctx = avctx;
if (!avctx->extradata) {
- av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n");
+ av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata!\n");
return -1;
}
if (read_specific_config(ctx)) {
- av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n");
+ av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed!\n");
decode_end(avctx);
return -1;
}
if (!ctx->quant_cof || !ctx->lpc_cof ||
!ctx->quant_cof_buffer || !ctx->lpc_cof_buffer ||
!ctx->lpc_cof_reversed_buffer) {
- av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
+ av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed!\n");
return AVERROR(ENOMEM);
}
!ctx->opt_order || !ctx->store_prev_samples ||
!ctx->use_ltp || !ctx->ltp_lag ||
!ctx->ltp_gain || !ctx->ltp_gain_buffer) {
- av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
+ av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed!\n");
decode_end(avctx);
return AVERROR(ENOMEM);
}
num_buffers);
if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) {
- av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
+ av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed!\n");
decode_end(avctx);
return AVERROR(ENOMEM);
}
// allocate previous raw sample buffer
if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) {
- av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
+ av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed!\n");
decode_end(avctx);
return AVERROR(ENOMEM);
}
// allocate crc buffer
if (HAVE_BIGENDIAN != sconf->msb_first && sconf->crc_enabled &&
- (avctx->err_recognition & AV_EF_CRCCHECK)) {
+ (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL))) {
ctx->crc_buffer = av_malloc(sizeof(*ctx->crc_buffer) *
ctx->cur_frame_length *
avctx->channels *
av_get_bytes_per_sample(avctx->sample_fmt));
if (!ctx->crc_buffer) {
- av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
+ av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed!\n");
decode_end(avctx);
return AVERROR(ENOMEM);
}
projects / ffmpeg / blobdiff