diff options
Diffstat (limited to 'libavcodec/adpcm.c')
| -rw-r--r-- | libavcodec/adpcm.c | 444 |
1 files changed, 371 insertions, 73 deletions
diff --git a/libavcodec/adpcm.c b/libavcodec/adpcm.c index c6bc4d09d7..2dac23bfa8 100644 --- a/libavcodec/adpcm.c +++ b/libavcodec/adpcm.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001-2003 The ffmpeg Project + * Copyright (c) 2001-2003 The FFmpeg Project * * first version by Francois Revol (revol@free.fr) * fringe ADPCM codecs (e.g., DK3, DK4, Westwood) @@ -13,25 +13,24 @@ * MAXIS EA ADPCM decoder by Robert Marston (rmarston@gmail.com) * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl) * - * 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 */ #include "avcodec.h" #include "get_bits.h" -#include "put_bits.h" #include "bytestream.h" #include "adpcm.h" #include "adpcm_data.h" @@ -85,8 +84,9 @@ static const int swf_index_tables[4][16] = { /* end of tables */ typedef struct ADPCMDecodeContext { - ADPCMChannelStatus status[6]; + ADPCMChannelStatus status[10]; int vqa_version; /**< VQA version. Used for ADPCM_IMA_WS */ + int has_status; } ADPCMDecodeContext; static av_cold int adpcm_decode_init(AVCodecContext * avctx) @@ -96,15 +96,21 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx) unsigned int max_channels = 2; switch(avctx->codec->id) { + case AV_CODEC_ID_ADPCM_DTK: case AV_CODEC_ID_ADPCM_EA: min_channels = 2; break; + case AV_CODEC_ID_ADPCM_AFC: case AV_CODEC_ID_ADPCM_EA_R1: case AV_CODEC_ID_ADPCM_EA_R2: case AV_CODEC_ID_ADPCM_EA_R3: case AV_CODEC_ID_ADPCM_EA_XAS: max_channels = 6; break; + case AV_CODEC_ID_ADPCM_THP: + case AV_CODEC_ID_ADPCM_THP_LE: + max_channels = 10; + break; } if (avctx->channels < min_channels || avctx->channels > max_channels) { av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n"); @@ -116,10 +122,8 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx) c->status[0].step = c->status[1].step = 511; break; case AV_CODEC_ID_ADPCM_IMA_WAV: - if (avctx->bits_per_coded_sample != 4) { - av_log(avctx, AV_LOG_ERROR, "Only 4-bit ADPCM IMA WAV files are supported\n"); - return -1; - } + if (avctx->bits_per_coded_sample < 2 || avctx->bits_per_coded_sample > 5) + return AVERROR_INVALIDDATA; break; case AV_CODEC_ID_ADPCM_IMA_APC: if (avctx->extradata && avctx->extradata_size >= 8) { @@ -145,6 +149,9 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx) case AV_CODEC_ID_ADPCM_EA_R3: case AV_CODEC_ID_ADPCM_EA_XAS: case AV_CODEC_ID_ADPCM_THP: + case AV_CODEC_ID_ADPCM_THP_LE: + case AV_CODEC_ID_ADPCM_AFC: + case AV_CODEC_ID_ADPCM_DTK: avctx->sample_fmt = AV_SAMPLE_FMT_S16P; break; case AV_CODEC_ID_ADPCM_IMA_WS: @@ -184,6 +191,29 @@ static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, return (short)c->predictor; } +static inline int16_t adpcm_ima_wav_expand_nibble(ADPCMChannelStatus *c, GetBitContext *gb, int bps) +{ + int nibble, step_index, predictor, sign, delta, diff, step, shift; + + shift = bps - 1; + nibble = get_bits_le(gb, bps), + step = ff_adpcm_step_table[c->step_index]; + step_index = c->step_index + ff_adpcm_index_tables[bps - 2][nibble]; + step_index = av_clip(step_index, 0, 88); + + sign = nibble & (1 << shift); + delta = av_mod_uintp2(nibble, shift); + diff = ((2 * delta + 1) * step) >> shift; + predictor = c->predictor; + if (sign) predictor -= diff; + else predictor += diff; + + c->predictor = av_clip_int16(predictor); + c->step_index = step_index; + + return (int16_t)c->predictor; +} + static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift) { int step_index; @@ -221,10 +251,35 @@ static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble) c->sample1 = av_clip_int16(predictor); c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8; if (c->idelta < 16) c->idelta = 16; + if (c->idelta > INT_MAX/768) { + av_log(NULL, AV_LOG_WARNING, "idelta overflow\n"); + c->idelta = INT_MAX/768; + } return c->sample1; } +static inline short adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble) +{ + int step_index, predictor, sign, delta, diff, step; + + step = ff_adpcm_oki_step_table[c->step_index]; + step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble]; + step_index = av_clip(step_index, 0, 48); + + sign = nibble & 8; + delta = nibble & 7; + diff = ((2 * delta + 1) * step) >> 3; + predictor = c->predictor; + if (sign) predictor -= diff; + else predictor += diff; + + c->predictor = av_clip_intp2(predictor, 11); + c->step_index = step_index; + + return c->predictor << 4; +} + static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble) { int sign, delta, diff; @@ -298,11 +353,9 @@ static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1, for(i=0;i<4;i++) { shift = 12 - (in[4+i*2] & 15); filter = in[4+i*2] >> 4; - if (filter > 4) { - av_log(avctx, AV_LOG_ERROR, - "Invalid XA-ADPCM filter %d (max. allowed is 4)\n", - filter); - return AVERROR_INVALIDDATA; + if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) { + avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter); + filter=0; } f0 = xa_adpcm_table[filter][0]; f1 = xa_adpcm_table[filter][1]; @@ -329,12 +382,11 @@ static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1, shift = 12 - (in[5+i*2] & 15); filter = in[5+i*2] >> 4; - if (filter > 4) { - av_log(avctx, AV_LOG_ERROR, - "Invalid XA-ADPCM filter %d (max. allowed is 4)\n", - filter); - return AVERROR_INVALIDDATA; + if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) { + avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter); + filter=0; } + f0 = xa_adpcm_table[filter][0]; f1 = xa_adpcm_table[filter][1]; @@ -428,9 +480,11 @@ static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_ * @param[out] coded_samples set to the number of samples as coded in the * packet, or 0 if the codec does not encode the * number of samples in each frame. + * @param[out] approx_nb_samples set to non-zero if the number of samples + * returned is an approximation. */ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, - int buf_size, int *coded_samples) + int buf_size, int *coded_samples, int *approx_nb_samples) { ADPCMDecodeContext *s = avctx->priv_data; int nb_samples = 0; @@ -439,6 +493,10 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, int header_size; *coded_samples = 0; + *approx_nb_samples = 0; + + if(ch <= 0) + return 0; switch (avctx->codec->id) { /* constant, only check buf_size */ @@ -456,6 +514,7 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, case AV_CODEC_ID_ADPCM_CT: case AV_CODEC_ID_ADPCM_IMA_APC: case AV_CODEC_ID_ADPCM_IMA_EA_SEAD: + case AV_CODEC_ID_ADPCM_IMA_OKI: case AV_CODEC_ID_ADPCM_IMA_WS: case AV_CODEC_ID_ADPCM_YAMAHA: nb_samples = buf_size * 2 / ch; @@ -470,7 +529,7 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, case AV_CODEC_ID_ADPCM_4XM: case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break; case AV_CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break; - case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4; break; + case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4 * ch; break; } if (header_size > 0) return (buf_size - header_size) * 2 / ch; @@ -514,6 +573,7 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, *coded_samples -= *coded_samples % 28; nb_samples = (buf_size - header_size) * 2 / ch; nb_samples -= nb_samples % 28; + *approx_nb_samples = 1; break; case AV_CODEC_ID_ADPCM_IMA_DK3: if (avctx->block_align > 0) @@ -523,17 +583,30 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, case AV_CODEC_ID_ADPCM_IMA_DK4: if (avctx->block_align > 0) buf_size = FFMIN(buf_size, avctx->block_align); + if (buf_size < 4 * ch) + return AVERROR_INVALIDDATA; nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch; break; + case AV_CODEC_ID_ADPCM_IMA_RAD: + if (avctx->block_align > 0) + buf_size = FFMIN(buf_size, avctx->block_align); + nb_samples = (buf_size - 4 * ch) * 2 / ch; + break; case AV_CODEC_ID_ADPCM_IMA_WAV: + { + int bsize = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2]; + int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2]; if (avctx->block_align > 0) buf_size = FFMIN(buf_size, avctx->block_align); - nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8; + if (buf_size < 4 * ch) + return AVERROR_INVALIDDATA; + nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples; break; + } case AV_CODEC_ID_ADPCM_MS: if (avctx->block_align > 0) buf_size = FFMIN(buf_size, avctx->block_align); - nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch; + nb_samples = (buf_size - 6 * ch) * 2 / ch; break; case AV_CODEC_ID_ADPCM_SBPRO_2: case AV_CODEC_ID_ADPCM_SBPRO_3: @@ -546,6 +619,8 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break; } if (!s->status[0].step_index) { + if (buf_size < ch) + return AVERROR_INVALIDDATA; nb_samples++; buf_size -= ch; } @@ -566,15 +641,32 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, break; } case AV_CODEC_ID_ADPCM_THP: + case AV_CODEC_ID_ADPCM_THP_LE: + if (avctx->extradata) { + nb_samples = buf_size * 14 / (8 * ch); + break; + } has_coded_samples = 1; bytestream2_skip(gb, 4); // channel size - *coded_samples = bytestream2_get_be32(gb); - *coded_samples -= *coded_samples % 14; - nb_samples = (buf_size - 80) / (8 * ch) * 14; + *coded_samples = (avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE) ? + bytestream2_get_le32(gb) : + bytestream2_get_be32(gb); + buf_size -= 8 + 36 * ch; + buf_size /= ch; + nb_samples = buf_size / 8 * 14; + if (buf_size % 8 > 1) + nb_samples += (buf_size % 8 - 1) * 2; + *approx_nb_samples = 1; + break; + case AV_CODEC_ID_ADPCM_AFC: + nb_samples = buf_size / (9 * ch) * 16; break; case AV_CODEC_ID_ADPCM_XA: nb_samples = (buf_size / 128) * 224 / ch; break; + case AV_CODEC_ID_ADPCM_DTK: + nb_samples = buf_size / (16 * ch) * 28; + break; } /* validate coded sample count */ @@ -597,11 +689,11 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, int16_t **samples_p; int st; /* stereo */ int count1, count2; - int nb_samples, coded_samples, ret; + int nb_samples, coded_samples, approx_nb_samples, ret; GetByteContext gb; bytestream2_init(&gb, buf, buf_size); - nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples); + nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples); if (nb_samples <= 0) { av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n"); return AVERROR_INVALIDDATA; @@ -609,17 +701,15 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, /* get output buffer */ frame->nb_samples = nb_samples; - if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) { - av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); + if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) return ret; - } samples = (short *)frame->data[0]; samples_p = (int16_t **)frame->extended_data; /* use coded_samples when applicable */ /* it is always <= nb_samples, so the output buffer will be large enough */ if (coded_samples) { - if (coded_samples != nb_samples) + if (!approx_nb_samples && coded_samples != nb_samples) av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n"); frame->nb_samples = nb_samples = coded_samples; } @@ -681,6 +771,23 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } } + if (avctx->bits_per_coded_sample != 4) { + int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2]; + GetBitContext g; + + init_get_bits8(&g, gb.buffer, bytestream2_get_bytes_left(&gb)); + for (n = 0; n < (nb_samples - 1) / samples_per_block; n++) { + for (i = 0; i < avctx->channels; i++) { + cs = &c->status[i]; + samples = &samples_p[i][1 + n * samples_per_block]; + for (m = 0; m < samples_per_block; m++) { + samples[m] = adpcm_ima_wav_expand_nibble(cs, &g, + avctx->bits_per_coded_sample); + } + } + } + bytestream2_skip(&gb, avctx->block_align - avctx->channels * 4); + } else { for (n = 0; n < (nb_samples - 1) / 8; n++) { for (i = 0; i < avctx->channels; i++) { cs = &c->status[i]; @@ -692,6 +799,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } } } + } break; case AV_CODEC_ID_ADPCM_4XM: for (i = 0; i < avctx->channels; i++) @@ -770,7 +878,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, return AVERROR_INVALIDDATA; } } - for (n = (nb_samples >> (1 - st)) - 1; n > 0; n--) { + for (n = (nb_samples - 1) >> (1 - st); n > 0; n--) { int v = bytestream2_get_byteu(&gb); *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3); *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3); @@ -835,6 +943,9 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, *samples++ = c->status[0].predictor + c->status[1].predictor; *samples++ = c->status[0].predictor - c->status[1].predictor; } + + if ((bytestream2_tell(&gb) & 1)) + bytestream2_skip(&gb, 1); break; } case AV_CODEC_ID_ADPCM_IMA_ISS: @@ -871,6 +982,38 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3); } break; + case AV_CODEC_ID_ADPCM_IMA_OKI: + while (bytestream2_get_bytes_left(&gb) > 0) { + int v = bytestream2_get_byteu(&gb); + *samples++ = adpcm_ima_oki_expand_nibble(&c->status[0], v >> 4 ); + *samples++ = adpcm_ima_oki_expand_nibble(&c->status[st], v & 0x0F); + } + break; + case AV_CODEC_ID_ADPCM_IMA_RAD: + for (channel = 0; channel < avctx->channels; channel++) { + cs = &c->status[channel]; + cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16); + cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16); + if (cs->step_index > 88u){ + av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n", + channel, cs->step_index); + return AVERROR_INVALIDDATA; + } + } + for (n = 0; n < nb_samples / 2; n++) { + int byte[2]; + + byte[0] = bytestream2_get_byteu(&gb); + if (st) + byte[1] = bytestream2_get_byteu(&gb); + for(channel = 0; channel < avctx->channels; channel++) { + *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] & 0x0F, 3); + } + for(channel = 0; channel < avctx->channels; channel++) { + *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] >> 4 , 3); + } + } + break; case AV_CODEC_ID_ADPCM_IMA_WS: if (c->vqa_version == 3) { for (channel = 0; channel < avctx->channels; channel++) { @@ -946,6 +1089,9 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces, each coding 28 stereo samples. */ + if(avctx->channels != 2) + return AVERROR_INVALIDDATA; + current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16); previous_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16); current_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16); @@ -1131,16 +1277,9 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } break; case AV_CODEC_ID_ADPCM_IMA_AMV: - case AV_CODEC_ID_ADPCM_IMA_SMJPEG: - if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) { - c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); - c->status[0].step_index = bytestream2_get_le16u(&gb); - bytestream2_skipu(&gb, 4); - } else { - c->status[0].predictor = sign_extend(bytestream2_get_be16u(&gb), 16); - c->status[0].step_index = bytestream2_get_byteu(&gb); - bytestream2_skipu(&gb, 1); - } + c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); + c->status[0].step_index = bytestream2_get_le16u(&gb); + bytestream2_skipu(&gb, 4); if (c->status[0].step_index > 88u) { av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", c->status[0].step_index); @@ -1148,18 +1287,29 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } for (n = nb_samples >> (1 - st); n > 0; n--) { - int hi, lo, v = bytestream2_get_byteu(&gb); + int v = bytestream2_get_byteu(&gb); - if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) { - hi = v & 0x0F; - lo = v >> 4; - } else { - lo = v & 0x0F; - hi = v >> 4; + *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3); + *samples++ = adpcm_ima_expand_nibble(&c->status[0], v & 0xf, 3); + } + break; + case AV_CODEC_ID_ADPCM_IMA_SMJPEG: + for (i = 0; i < avctx->channels; i++) { + c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16); + c->status[i].step_index = bytestream2_get_byteu(&gb); + bytestream2_skipu(&gb, 1); + if (c->status[i].step_index > 88u) { + av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", + c->status[i].step_index); + return AVERROR_INVALIDDATA; } + } + + for (n = nb_samples >> (1 - st); n > 0; n--) { + int v = bytestream2_get_byteu(&gb); - *samples++ = adpcm_ima_expand_nibble(&c->status[0], lo, 3); - *samples++ = adpcm_ima_expand_nibble(&c->status[0], hi, 3); + *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4, 3); + *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf, 3); } break; case AV_CODEC_ID_ADPCM_CT: @@ -1189,7 +1339,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, byte & 0x0F, 4, 0); } } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) { - for (n = nb_samples / 3; n > 0; n--) { + for (n = (nb_samples<<st) / 3; n > 0; n--) { int byte = bytestream2_get_byteu(&gb); *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], byte >> 5 , 3, 0); @@ -1223,26 +1373,104 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 ); } break; + case AV_CODEC_ID_ADPCM_AFC: + { + int samples_per_block; + int blocks; + + if (avctx->extradata && avctx->extradata_size == 1 && avctx->extradata[0]) { + samples_per_block = avctx->extradata[0] / 16; + blocks = nb_samples / avctx->extradata[0]; + } else { + samples_per_block = nb_samples / 16; + blocks = 1; + } + + for (m = 0; m < blocks; m++) { + for (channel = 0; channel < avctx->channels; channel++) { + int prev1 = c->status[channel].sample1; + int prev2 = c->status[channel].sample2; + + samples = samples_p[channel] + m * 16; + /* Read in every sample for this channel. */ + for (i = 0; i < samples_per_block; i++) { + int byte = bytestream2_get_byteu(&gb); + int scale = 1 << (byte >> 4); + int index = byte & 0xf; + int factor1 = ff_adpcm_afc_coeffs[0][index]; + int factor2 = ff_adpcm_afc_coeffs[1][index]; + + /* Decode 16 samples. */ + for (n = 0; n < 16; n++) { + int32_t sampledat; + + if (n & 1) { + sampledat = sign_extend(byte, 4); + } else { + byte = bytestream2_get_byteu(&gb); + sampledat = sign_extend(byte >> 4, 4); + } + + sampledat = ((prev1 * factor1 + prev2 * factor2) + + ((sampledat * scale) << 11)) >> 11; + *samples = av_clip_int16(sampledat); + prev2 = prev1; + prev1 = *samples++; + } + } + + c->status[channel].sample1 = prev1; + c->status[channel].sample2 = prev2; + } + } + bytestream2_seek(&gb, 0, SEEK_END); + break; + } case AV_CODEC_ID_ADPCM_THP: + case AV_CODEC_ID_ADPCM_THP_LE: { - int table[2][16]; - int prev[2][2]; + int table[10][16]; int ch; - for (i = 0; i < 2; i++) - for (n = 0; n < 16; n++) - table[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16); +#define THP_GET16(g) \ + sign_extend( \ + avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE ? \ + bytestream2_get_le16u(&(g)) : \ + bytestream2_get_be16u(&(g)), 16) + + if (avctx->extradata) { + GetByteContext tb; + if (avctx->extradata_size < 32 * avctx->channels) { + av_log(avctx, AV_LOG_ERROR, "Missing coeff table\n"); + return AVERROR_INVALIDDATA; + } - /* Initialize the previous sample. */ - for (i = 0; i < 2; i++) - for (n = 0; n < 2; n++) - prev[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16); + bytestream2_init(&tb, avctx->extradata, avctx->extradata_size); + for (i = 0; i < avctx->channels; i++) + for (n = 0; n < 16; n++) + table[i][n] = THP_GET16(tb); + } else { + for (i = 0; i < avctx->channels; i++) + for (n = 0; n < 16; n++) + table[i][n] = THP_GET16(gb); + + if (!c->has_status) { + /* Initialize the previous sample. */ + for (i = 0; i < avctx->channels; i++) { + c->status[i].sample1 = THP_GET16(gb); + c->status[i].sample2 = THP_GET16(gb); + } + c->has_status = 1; + } else { + bytestream2_skip(&gb, avctx->channels * 4); + } + } - for (ch = 0; ch <= st; ch++) { + for (ch = 0; ch < avctx->channels; ch++) { samples = samples_p[ch]; /* Read in every sample for this channel. */ - for (i = 0; i < nb_samples / 14; i++) { + for (i = 0; i < (nb_samples + 13) / 14; i++) { int byte = bytestream2_get_byteu(&gb); int index = (byte >> 4) & 7; unsigned int exp = byte & 0x0F; @@ -1250,7 +1478,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, int factor2 = table[ch][index * 2 + 1]; /* Decode 14 samples. */ - for (n = 0; n < 14; n++) { + for (n = 0; n < 14 && (i * 14 + n < nb_samples); n++) { int32_t sampledat; if (n & 1) { @@ -1260,30 +1488,94 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, sampledat = sign_extend(byte >> 4, 4); } - sampledat = ((prev[ch][0]*factor1 - + prev[ch][1]*factor2) >> 11) + (sampledat << exp); + sampledat = ((c->status[ch].sample1 * factor1 + + c->status[ch].sample2 * factor2) >> 11) + (sampledat << exp); *samples = av_clip_int16(sampledat); - prev[ch][1] = prev[ch][0]; - prev[ch][0] = *samples++; + c->status[ch].sample2 = c->status[ch].sample1; + c->status[ch].sample1 = *samples++; } } } break; } + case AV_CODEC_ID_ADPCM_DTK: + for (channel = 0; channel < avctx->channels; channel++) { + samples = samples_p[channel]; + + /* Read in every sample for this channel. */ + for (i = 0; i < nb_samples / 28; i++) { + int byte, header; + if (channel) + bytestream2_skipu(&gb, 1); + header = bytestream2_get_byteu(&gb); + bytestream2_skipu(&gb, 3 - channel); + + /* Decode 28 samples. */ + for (n = 0; n < 28; n++) { + int32_t sampledat, prev; + + switch (header >> 4) { + case 1: + prev = (c->status[channel].sample1 * 0x3c); + break; + case 2: + prev = (c->status[channel].sample1 * 0x73) - (c->status[channel].sample2 * 0x34); + break; + case 3: + prev = (c->status[channel].sample1 * 0x62) - (c->status[channel].sample2 * 0x37); + break; + default: + prev = 0; + } + + prev = av_clip_intp2((prev + 0x20) >> 6, 21); + + byte = bytestream2_get_byteu(&gb); + if (!channel) + sampledat = sign_extend(byte, 4); + else + sampledat = sign_extend(byte >> 4, 4); + + sampledat = (((sampledat << 12) >> (header & 0xf)) << 6) + prev; + *samples++ = av_clip_int16(sampledat >> 6); + c->status[channel].sample2 = c->status[channel].sample1; + c->status[channel].sample1 = sampledat; + } + } + if (!channel) + bytestream2_seek(&gb, 0, SEEK_SET); + } + break; default: return -1; } + if (avpkt->size && bytestream2_tell(&gb) == 0) { + av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n"); + return AVERROR_INVALIDDATA; + } + *got_frame_ptr = 1; + if (avpkt->size < bytestream2_tell(&gb)) { + av_log(avctx, AV_LOG_ERROR, "Overread of %d < %d\n", avpkt->size, bytestream2_tell(&gb)); + return avpkt->size; + } + return bytestream2_tell(&gb); } +static void adpcm_flush(AVCodecContext *avctx) +{ + ADPCMDecodeContext *c = avctx->priv_data; + c->has_status = 0; +} + static const enum AVSampleFormat sample_fmts_s16[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE }; -static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16, +static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_NONE }; static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P, @@ -1298,13 +1590,16 @@ AVCodec ff_ ## name_ ## _decoder = { \ .priv_data_size = sizeof(ADPCMDecodeContext), \ .init = adpcm_decode_init, \ .decode = adpcm_decode_frame, \ + .flush = adpcm_flush, \ .capabilities = CODEC_CAP_DR1, \ .sample_fmts = sample_fmts_, \ } /* Note: Do not forget to add new entries to the Makefile as well. */ ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM, sample_fmts_s16p, adpcm_4xm, "ADPCM 4X Movie"); +ADPCM_DECODER(AV_CODEC_ID_ADPCM_AFC, sample_fmts_s16p, adpcm_afc, "ADPCM Nintendo Gamecube AFC"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT, sample_fmts_s16, adpcm_ct, "ADPCM Creative Technology"); +ADPCM_DECODER(AV_CODEC_ID_ADPCM_DTK, sample_fmts_s16p, adpcm_dtk, "ADPCM Nintendo Gamecube DTK"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA, sample_fmts_s16, adpcm_ea, "ADPCM Electronic Arts"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_MAXIS_XA, sample_fmts_s16, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1, sample_fmts_s16p, adpcm_ea_r1, "ADPCM Electronic Arts R1"); @@ -1318,7 +1613,9 @@ ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4, sample_fmts_s16, adpcm_ima_dk4, ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_EACS, sample_fmts_s16, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_SEAD, sample_fmts_s16, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ISS, sample_fmts_s16, adpcm_ima_iss, "ADPCM IMA Funcom ISS"); +ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_OKI, sample_fmts_s16, adpcm_ima_oki, "ADPCM IMA Dialogic OKI"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT, sample_fmts_s16p, adpcm_ima_qt, "ADPCM IMA QuickTime"); +ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_RAD, sample_fmts_s16, adpcm_ima_rad, "ADPCM IMA Radical"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG, sample_fmts_s16, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV, sample_fmts_s16p, adpcm_ima_wav, "ADPCM IMA WAV"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS, sample_fmts_both, adpcm_ima_ws, "ADPCM IMA Westwood"); @@ -1327,6 +1624,7 @@ ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2, sample_fmts_s16, adpcm_sbpro_2, ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_3, sample_fmts_s16, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_4, sample_fmts_s16, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_SWF, sample_fmts_s16, adpcm_swf, "ADPCM Shockwave Flash"); -ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP, sample_fmts_s16p, adpcm_thp, "ADPCM Nintendo Gamecube THP"); +ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP_LE, sample_fmts_s16p, adpcm_thp_le, "ADPCM Nintendo THP (little-endian)"); +ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP, sample_fmts_s16p, adpcm_thp, "ADPCM Nintendo THP"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA, sample_fmts_s16p, adpcm_xa, "ADPCM CDROM XA"); ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA, sample_fmts_s16, adpcm_yamaha, "ADPCM Yamaha"); |