GetBitContext gb;
int min_framesize, max_framesize;
- int channels;
+ unsigned channels;
int32_t *decoded[MAX_CHANNELS];
int32_t *decoded_base[MAX_CHANNELS];
static int allocate_buffers(ShortenContext *s)
{
- int i, chan;
- int *coeffs;
- void *tmp_ptr;
+ int i, chan, err;
for (chan = 0; chan < s->channels; chan++) {
if (FFMAX(1, s->nmean) >= UINT_MAX / sizeof(int32_t)) {
av_log(s->avctx, AV_LOG_ERROR, "nmean too large\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (s->blocksize + s->nwrap >= UINT_MAX / sizeof(int32_t) ||
s->blocksize + s->nwrap <= (unsigned)s->nwrap) {
av_log(s->avctx, AV_LOG_ERROR,
"s->blocksize + s->nwrap too large\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
- tmp_ptr =
- av_realloc(s->offset[chan], sizeof(int32_t) * FFMAX(1, s->nmean));
- if (!tmp_ptr)
- return AVERROR(ENOMEM);
- s->offset[chan] = tmp_ptr;
+ if ((err = av_reallocp(&s->offset[chan],
+ sizeof(int32_t) *
+ FFMAX(1, s->nmean))) < 0)
+ return err;
- tmp_ptr = av_realloc(s->decoded_base[chan], (s->blocksize + s->nwrap) *
- sizeof(s->decoded_base[0][0]));
- if (!tmp_ptr)
- return AVERROR(ENOMEM);
- s->decoded_base[chan] = tmp_ptr;
+ if ((err = av_reallocp(&s->decoded_base[chan], (s->blocksize + s->nwrap) *
+ sizeof(s->decoded_base[0][0]))) < 0)
+ return err;
for (i = 0; i < s->nwrap; i++)
s->decoded_base[chan][i] = 0;
s->decoded[chan] = s->decoded_base[chan] + s->nwrap;
}
- coeffs = av_realloc(s->coeffs, s->nwrap * sizeof(*s->coeffs));
- if (!coeffs)
- return AVERROR(ENOMEM);
- s->coeffs = coeffs;
+ if ((err = av_reallocp(&s->coeffs, s->nwrap * sizeof(*s->coeffs))) < 0)
+ return err;
return 0;
}
{
int len;
short wave_format;
+ GetByteContext gb;
- if (bytestream_get_le32(&header) != MKTAG('R', 'I', 'F', 'F')) {
+ bytestream2_init(&gb, header, header_size);
+
+ if (bytestream2_get_le32(&gb) != MKTAG('R', 'I', 'F', 'F')) {
av_log(avctx, AV_LOG_ERROR, "missing RIFF tag\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
- header += 4; /* chunk size */
+ bytestream2_skip(&gb, 4); /* chunk size */
- if (bytestream_get_le32(&header) != MKTAG('W', 'A', 'V', 'E')) {
+ if (bytestream2_get_le32(&gb) != MKTAG('W', 'A', 'V', 'E')) {
av_log(avctx, AV_LOG_ERROR, "missing WAVE tag\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
- while (bytestream_get_le32(&header) != MKTAG('f', 'm', 't', ' ')) {
- len = bytestream_get_le32(&header);
- header += len;
+ while (bytestream2_get_le32(&gb) != MKTAG('f', 'm', 't', ' ')) {
+ len = bytestream2_get_le32(&gb);
+ bytestream2_skip(&gb, len);
+ if (bytestream2_get_bytes_left(&gb) < 16) {
+ av_log(avctx, AV_LOG_ERROR, "no fmt chunk found\n");
+ return AVERROR_INVALIDDATA;
+ }
}
- len = bytestream_get_le32(&header);
+ len = bytestream2_get_le32(&gb);
if (len < 16) {
av_log(avctx, AV_LOG_ERROR, "fmt chunk was too short\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
- wave_format = bytestream_get_le16(&header);
+ wave_format = bytestream2_get_le16(&gb);
switch (wave_format) {
case WAVE_FORMAT_PCM:
break;
default:
av_log(avctx, AV_LOG_ERROR, "unsupported wave format\n");
- return -1;
+ return AVERROR(ENOSYS);
}
- header += 2; // skip channels (already got from shorten header)
- avctx->sample_rate = bytestream_get_le32(&header);
- header += 4; // skip bit rate (represents original uncompressed bit rate)
- header += 2; // skip block align (not needed)
- avctx->bits_per_coded_sample = bytestream_get_le16(&header);
+ bytestream2_skip(&gb, 2); // skip channels (already got from shorten header)
+ avctx->sample_rate = bytestream2_get_le32(&gb);
+ bytestream2_skip(&gb, 4); // skip bit rate (represents original uncompressed bit rate)
+ bytestream2_skip(&gb, 2); // skip block align (not needed)
+ avctx->bits_per_coded_sample = bytestream2_get_le16(&gb);
if (avctx->bits_per_coded_sample != 16) {
av_log(avctx, AV_LOG_ERROR, "unsupported number of bits per sample\n");
- return -1;
+ return AVERROR(ENOSYS);
}
len -= 16;
}
}
-static const int fixed_coeffs[3][3] = {
+static const int fixed_coeffs[][3] = {
+ { 0, 0, 0 },
{ 1, 0, 0 },
{ 2, -1, 0 },
{ 3, -3, 1 }
} else {
/* fixed LPC coeffs */
pred_order = command;
- coeffs = fixed_coeffs[pred_order - 1];
+ if (pred_order >= FF_ARRAY_ELEMS(fixed_coeffs)) {
+ av_log(s->avctx, AV_LOG_ERROR, "invalid pred_order %d\n",
+ pred_order);
+ return AVERROR_INVALIDDATA;
+ }
+ coeffs = fixed_coeffs[pred_order];
qshift = 0;
}
/* shorten signature */
if (get_bits_long(&s->gb, 32) != AV_RB32("ajkg")) {
av_log(s->avctx, AV_LOG_ERROR, "missing shorten magic 'ajkg'\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
s->lpcqoffset = 0;
s->internal_ftype = get_uint(s, TYPESIZE);
s->channels = get_uint(s, CHANSIZE);
- if (s->channels <= 0 || s->channels > MAX_CHANNELS) {
+ if (!s->channels) {
+ av_log(s->avctx, AV_LOG_ERROR, "No channels reported\n");
+ return AVERROR_INVALIDDATA;
+ }
+ if (s->channels > MAX_CHANNELS) {
av_log(s->avctx, AV_LOG_ERROR, "too many channels: %d\n", s->channels);
s->channels = 0;
- return -1;
+ return AVERROR_INVALIDDATA;
}
s->avctx->channels = s->channels;
/* get blocksize if version > 0 */
if (s->version > 0) {
- int skip_bytes, blocksize;
+ int skip_bytes;
+ unsigned blocksize;
blocksize = get_uint(s, av_log2(DEFAULT_BLOCK_SIZE));
if (!blocksize || blocksize > MAX_BLOCKSIZE) {
if (get_ur_golomb_shorten(&s->gb, FNSIZE) != FN_VERBATIM) {
av_log(s->avctx, AV_LOG_ERROR,
"missing verbatim section at beginning of stream\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
s->header_size = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
s->header_size < CANONICAL_HEADER_SIZE) {
av_log(s->avctx, AV_LOG_ERROR, "header is wrong size: %d\n",
s->header_size);
- return -1;
+ return AVERROR_INVALIDDATA;
}
for (i = 0; i < s->header_size; i++)
s->header[i] = (char)get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
- if (decode_wave_header(s->avctx, s->header, s->header_size) < 0)
- return -1;
+ if ((ret = decode_wave_header(s->avctx, s->header, s->header_size)) < 0)
+ return ret;
s->cur_chan = 0;
s->bitshift = 0;
s->bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE);
break;
case FN_BLOCKSIZE: {
- int blocksize = get_uint(s, av_log2(s->blocksize));
+ unsigned blocksize = get_uint(s, av_log2(s->blocksize));
if (blocksize > s->blocksize) {
av_log(avctx, AV_LOG_ERROR,
"Increasing block size is not supported\n");
if (s->cur_chan == s->channels) {
/* get output buffer */
frame->nb_samples = s->blocksize;
- if ((ret = ff_get_buffer(avctx, frame)) < 0) {
+ if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
s->bitstream_size = 0;
s->bitstream_index = 0;
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (s->bitstream_size) {
s->bitstream_index += i;
AVCodec ff_shorten_decoder = {
.name = "shorten",
+ .long_name = NULL_IF_CONFIG_SMALL("Shorten"),
.type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_SHORTEN,
.priv_data_size = sizeof(ShortenContext),
.close = shorten_decode_close,
.decode = shorten_decode_frame,
.capabilities = CODEC_CAP_DELAY | CODEC_CAP_DR1,
- .long_name = NULL_IF_CONFIG_SMALL("Shorten"),
.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
AV_SAMPLE_FMT_NONE },
};