adpcm.c 60.6 KB
Newer Older
1
/*
2
 * Copyright (c) 2001-2003 The FFmpeg Project
3
 *
4 5 6 7 8 9 10 11 12 13 14 15
 * first version by Francois Revol (revol@free.fr)
 * fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
 *   by Mike Melanson (melanson@pcisys.net)
 * CD-ROM XA ADPCM codec by BERO
 * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com)
 * EA ADPCM R1/R2/R3 decoder by Peter Ross (pross@xvid.org)
 * EA IMA EACS decoder by Peter Ross (pross@xvid.org)
 * EA IMA SEAD decoder by Peter Ross (pross@xvid.org)
 * EA ADPCM XAS decoder by Peter Ross (pross@xvid.org)
 * MAXIS EA ADPCM decoder by Robert Marston (rmarston@gmail.com)
 * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl)
 *
16 17 18
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
19 20
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
21
 * version 2.1 of the License, or (at your option) any later version.
22
 *
23
 * FFmpeg is distributed in the hope that it will be useful,
24 25 26 27 28
 * 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
29
 * License along with FFmpeg; if not, write to the Free Software
30
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 32
 */
#include "avcodec.h"
33
#include "get_bits.h"
34
#include "bytestream.h"
35 36
#include "adpcm.h"
#include "adpcm_data.h"
37
#include "internal.h"
38

Michael Niedermayer's avatar
Michael Niedermayer committed
39
/**
40
 * @file
41
 * ADPCM decoders
42 43 44
 * Features and limitations:
 *
 * Reference documents:
45 46 47 48 49 50 51
 * http://wiki.multimedia.cx/index.php?title=Category:ADPCM_Audio_Codecs
 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html [dead]
 * http://www.geocities.com/SiliconValley/8682/aud3.txt [dead]
 * http://openquicktime.sourceforge.net/
 * XAnim sources (xa_codec.c) http://xanim.polter.net/
 * http://www.cs.ucla.edu/~leec/mediabench/applications.html [dead]
 * SoX source code http://sox.sourceforge.net/
52 53
 *
 * CD-ROM XA:
54 55
 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html [dead]
 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html [dead]
56
 * readstr http://www.geocities.co.jp/Playtown/2004/
57 58
 */

59
/* These are for CD-ROM XA ADPCM */
Alex Beregszaszi's avatar
Alex Beregszaszi committed
60
static const int xa_adpcm_table[5][2] = {
61 62 63 64 65
    {   0,   0 },
    {  60,   0 },
    { 115, -52 },
    {  98, -55 },
    { 122, -60 }
66 67
};

Michael Niedermayer's avatar
Michael Niedermayer committed
68
static const int ea_adpcm_table[] = {
69 70 71 72 73
    0,  240,  460,  392,
    0,    0, -208, -220,
    0,    1,    3,    4,
    7,    8,   10,   11,
    0,   -1,   -3,   -4
74 75
};

76
// padded to zero where table size is less then 16
Michael Niedermayer's avatar
Michael Niedermayer committed
77
static const int swf_index_tables[4][16] = {
78 79 80 81 82 83
    /*2*/ { -1, 2 },
    /*3*/ { -1, -1, 2, 4 },
    /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },
    /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
};

84 85
/* end of tables */

86
typedef struct ADPCMDecodeContext {
87
    ADPCMChannelStatus status[6];
88
    int vqa_version;                /**< VQA version. Used for ADPCM_IMA_WS */
89
} ADPCMDecodeContext;
90

91
static av_cold int adpcm_decode_init(AVCodecContext * avctx)
92
{
93
    ADPCMDecodeContext *c = avctx->priv_data;
94
    unsigned int min_channels = 1;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
95
    unsigned int max_channels = 2;
96

97
    switch(avctx->codec->id) {
James Almer's avatar
James Almer committed
98
    case AV_CODEC_ID_ADPCM_DTK:
99
    case AV_CODEC_ID_ADPCM_EA:
100 101
        min_channels = 2;
        break;
102
    case AV_CODEC_ID_ADPCM_AFC:
103 104 105 106
    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:
107
    case AV_CODEC_ID_ADPCM_THP:
108 109 110
        max_channels = 6;
        break;
    }
111
    if (avctx->channels < min_channels || avctx->channels > max_channels) {
112 113
        av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
        return AVERROR(EINVAL);
114 115
    }

116
    switch(avctx->codec->id) {
117
    case AV_CODEC_ID_ADPCM_CT:
118 119
        c->status[0].step = c->status[1].step = 511;
        break;
120
    case AV_CODEC_ID_ADPCM_IMA_WAV:
121 122
        if (avctx->bits_per_coded_sample < 2 || avctx->bits_per_coded_sample > 5)
            return AVERROR_INVALIDDATA;
123
        break;
124
    case AV_CODEC_ID_ADPCM_IMA_APC:
125
        if (avctx->extradata && avctx->extradata_size >= 8) {
Anssi Hannula's avatar
Anssi Hannula committed
126 127 128 129
            c->status[0].predictor = AV_RL32(avctx->extradata);
            c->status[1].predictor = AV_RL32(avctx->extradata + 4);
        }
        break;
130
    case AV_CODEC_ID_ADPCM_IMA_WS:
131
        if (avctx->extradata && avctx->extradata_size >= 2)
132 133
            c->vqa_version = AV_RL16(avctx->extradata);
        break;
134 135 136
    default:
        break;
    }
137 138 139

    switch(avctx->codec->id) {
        case AV_CODEC_ID_ADPCM_IMA_QT:
140
        case AV_CODEC_ID_ADPCM_IMA_WAV:
141
        case AV_CODEC_ID_ADPCM_4XM:
142
        case AV_CODEC_ID_ADPCM_XA:
143 144 145
        case AV_CODEC_ID_ADPCM_EA_R1:
        case AV_CODEC_ID_ADPCM_EA_R2:
        case AV_CODEC_ID_ADPCM_EA_R3:
146
        case AV_CODEC_ID_ADPCM_EA_XAS:
147
        case AV_CODEC_ID_ADPCM_THP:
Paul B Mahol's avatar
Paul B Mahol committed
148
        case AV_CODEC_ID_ADPCM_AFC:
James Almer's avatar
James Almer committed
149
        case AV_CODEC_ID_ADPCM_DTK:
150 151
            avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
            break;
152 153 154 155
        case AV_CODEC_ID_ADPCM_IMA_WS:
            avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
                                                      AV_SAMPLE_FMT_S16;
            break;
156 157 158
        default:
            avctx->sample_fmt = AV_SAMPLE_FMT_S16;
    }
159

160 161 162
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
163
static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
164 165 166 167 168
{
    int step_index;
    int predictor;
    int sign, delta, diff, step;

169 170
    step = ff_adpcm_step_table[c->step_index];
    step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
171
    step_index = av_clip(step_index, 0, 88);
172 173 174

    sign = nibble & 8;
    delta = nibble & 7;
175 176 177
    /* perform direct multiplication instead of series of jumps proposed by
     * the reference ADPCM implementation since modern CPUs can do the mults
     * quickly enough */
Michael Niedermayer's avatar
Michael Niedermayer committed
178
    diff = ((2 * delta + 1) * step) >> shift;
Michael Niedermayer's avatar
Michael Niedermayer committed
179 180 181 182
    predictor = c->predictor;
    if (sign) predictor -= diff;
    else predictor += diff;

183
    c->predictor = av_clip_int16(predictor);
Michael Niedermayer's avatar
Michael Niedermayer committed
184 185
    c->step_index = step_index;

186
    return (short)c->predictor;
Michael Niedermayer's avatar
Michael Niedermayer committed
187 188
}

189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
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 = nibble & ((1 << shift) - 1);
    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;
}

212 213 214 215 216 217
static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
{
    int step_index;
    int predictor;
    int diff, step;

218 219
    step = ff_adpcm_step_table[c->step_index];
    step_index = c->step_index + ff_adpcm_index_table[nibble];
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
    step_index = av_clip(step_index, 0, 88);

    diff = step >> 3;
    if (nibble & 4) diff += step;
    if (nibble & 2) diff += step >> 1;
    if (nibble & 1) diff += step >> 2;

    if (nibble & 8)
        predictor = c->predictor - diff;
    else
        predictor = c->predictor + diff;

    c->predictor = av_clip_int16(predictor);
    c->step_index = step_index;

    return c->predictor;
}

238
static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
239 240 241
{
    int predictor;

242
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
243
    predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
244 245

    c->sample2 = c->sample1;
246
    c->sample1 = av_clip_int16(predictor);
247
    c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
248 249
    if (c->idelta < 16) c->idelta = 16;

250
    return c->sample1;
251 252
}

253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
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(predictor, -2048, 2047);
    c->step_index = step_index;

    return c->predictor << 4;
}

274 275 276 277 278 279 280 281 282 283 284 285
static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
{
    int sign, delta, diff;
    int new_step;

    sign = nibble & 8;
    delta = nibble & 7;
    /* perform direct multiplication instead of series of jumps proposed by
     * the reference ADPCM implementation since modern CPUs can do the mults
     * quickly enough */
    diff = ((2 * delta + 1) * c->step) >> 3;
    /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
286 287
    c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
    c->predictor = av_clip_int16(c->predictor);
288
    /* calculate new step and clamp it to range 511..32767 */
289
    new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
290
    c->step = av_clip(new_step, 511, 32767);
291

292
    return (short)c->predictor;
293 294
}

295 296 297 298 299 300 301 302 303
static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
{
    int sign, delta, diff;

    sign = nibble & (1<<(size-1));
    delta = nibble & ((1<<(size-1))-1);
    diff = delta << (7 + c->step + shift);

    /* clamp result */
304
    c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
305 306 307 308 309 310 311 312 313 314

    /* calculate new step */
    if (delta >= (2*size - 3) && c->step < 3)
        c->step++;
    else if (delta == 0 && c->step > 0)
        c->step--;

    return (short) c->predictor;
}

315 316 317 318 319 320 321
static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
{
    if(!c->step) {
        c->predictor = 0;
        c->step = 127;
    }

322
    c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
323
    c->predictor = av_clip_int16(c->predictor);
324
    c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
325
    c->step = av_clip(c->step, 127, 24567);
326 327 328
    return c->predictor;
}

329 330 331
static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
                     const uint8_t *in, ADPCMChannelStatus *left,
                     ADPCMChannelStatus *right, int channels, int sample_offset)
332 333 334 335 336 337
{
    int i, j;
    int shift,filter,f0,f1;
    int s_1,s_2;
    int d,s,t;

338 339 340 341 342
    out0 += sample_offset;
    if (channels == 1)
        out1 = out0 + 28;
    else
        out1 += sample_offset;
343

344
    for(i=0;i<4;i++) {
345 346
        shift  = 12 - (in[4+i*2] & 15);
        filter = in[4+i*2] >> 4;
347
        if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
348
            avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
349 350
            filter=0;
        }
351 352 353 354 355 356 357 358 359
        f0 = xa_adpcm_table[filter][0];
        f1 = xa_adpcm_table[filter][1];

        s_1 = left->sample1;
        s_2 = left->sample2;

        for(j=0;j<28;j++) {
            d = in[16+i+j*4];

360
            t = sign_extend(d, 4);
361 362
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
            s_2 = s_1;
363
            s_1 = av_clip_int16(s);
364
            out0[j] = s_1;
365 366
        }

367
        if (channels == 2) {
368 369 370 371 372 373 374 375
            left->sample1 = s_1;
            left->sample2 = s_2;
            s_1 = right->sample1;
            s_2 = right->sample2;
        }

        shift  = 12 - (in[5+i*2] & 15);
        filter = in[5+i*2] >> 4;
376
        if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
377
            avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
378 379
            filter=0;
        }
380 381 382 383 384 385 386

        f0 = xa_adpcm_table[filter][0];
        f1 = xa_adpcm_table[filter][1];

        for(j=0;j<28;j++) {
            d = in[16+i+j*4];

387
            t = sign_extend(d >> 4, 4);
388 389
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
            s_2 = s_1;
390
            s_1 = av_clip_int16(s);
391
            out1[j] = s_1;
392 393
        }

394
        if (channels == 2) {
395 396 397 398 399 400
            right->sample1 = s_1;
            right->sample2 = s_2;
        } else {
            left->sample1 = s_1;
            left->sample2 = s_2;
        }
401 402 403

        out0 += 28 * (3 - channels);
        out1 += 28 * (3 - channels);
404
    }
405 406

    return 0;
407 408
}

409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
{
    ADPCMDecodeContext *c = avctx->priv_data;
    GetBitContext gb;
    const int *table;
    int k0, signmask, nb_bits, count;
    int size = buf_size*8;
    int i;

    init_get_bits(&gb, buf, size);

    //read bits & initial values
    nb_bits = get_bits(&gb, 2)+2;
    table = swf_index_tables[nb_bits-2];
    k0 = 1 << (nb_bits-2);
    signmask = 1 << (nb_bits-1);

    while (get_bits_count(&gb) <= size - 22*avctx->channels) {
        for (i = 0; i < avctx->channels; i++) {
            *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
            c->status[i].step_index = get_bits(&gb, 6);
        }

        for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
            int i;

            for (i = 0; i < avctx->channels; i++) {
                // similar to IMA adpcm
                int delta = get_bits(&gb, nb_bits);
                int step = ff_adpcm_step_table[c->status[i].step_index];
                long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
                int k = k0;

                do {
                    if (delta & k)
                        vpdiff += step;
                    step >>= 1;
                    k >>= 1;
                } while(k);
                vpdiff += step;

                if (delta & signmask)
                    c->status[i].predictor -= vpdiff;
                else
                    c->status[i].predictor += vpdiff;

                c->status[i].step_index += table[delta & (~signmask)];

                c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
                c->status[i].predictor = av_clip_int16(c->status[i].predictor);

                *samples++ = c->status[i].predictor;
            }
        }
    }
}

466 467 468 469 470 471 472 473
/**
 * Get the number of samples that will be decoded from the packet.
 * In one case, this is actually the maximum number of samples possible to
 * decode with the given buf_size.
 *
 * @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.
474 475
 * @param[out] approx_nb_samples set to non-zero if the number of samples
 *                               returned is an approximation.
476
 */
477
static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
478
                          int buf_size, int *coded_samples, int *approx_nb_samples)
479 480 481 482 483 484 485 486
{
    ADPCMDecodeContext *s = avctx->priv_data;
    int nb_samples        = 0;
    int ch                = avctx->channels;
    int has_coded_samples = 0;
    int header_size;

    *coded_samples = 0;
487
    *approx_nb_samples = 0;
488

489 490 491
    if(ch <= 0)
        return 0;

492 493
    switch (avctx->codec->id) {
    /* constant, only check buf_size */
494
    case AV_CODEC_ID_ADPCM_EA_XAS:
495 496 497 498
        if (buf_size < 76 * ch)
            return 0;
        nb_samples = 128;
        break;
499
    case AV_CODEC_ID_ADPCM_IMA_QT:
500 501 502 503 504
        if (buf_size < 34 * ch)
            return 0;
        nb_samples = 64;
        break;
    /* simple 4-bit adpcm */
505 506 507
    case AV_CODEC_ID_ADPCM_CT:
    case AV_CODEC_ID_ADPCM_IMA_APC:
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
508
    case AV_CODEC_ID_ADPCM_IMA_OKI:
509 510
    case AV_CODEC_ID_ADPCM_IMA_WS:
    case AV_CODEC_ID_ADPCM_YAMAHA:
511 512 513 514 515 516 517 518 519
        nb_samples = buf_size * 2 / ch;
        break;
    }
    if (nb_samples)
        return nb_samples;

    /* simple 4-bit adpcm, with header */
    header_size = 0;
    switch (avctx->codec->id) {
520 521 522
        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;
523
        case AV_CODEC_ID_ADPCM_IMA_SMJPEG:  header_size = 4 * ch;      break;
524 525 526 527 528 529
    }
    if (header_size > 0)
        return (buf_size - header_size) * 2 / ch;

    /* more complex formats */
    switch (avctx->codec->id) {
530
    case AV_CODEC_ID_ADPCM_EA:
531
        has_coded_samples = 1;
532
        *coded_samples  = bytestream2_get_le32(gb);
533 534 535
        *coded_samples -= *coded_samples % 28;
        nb_samples      = (buf_size - 12) / 30 * 28;
        break;
536
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
537
        has_coded_samples = 1;
538
        *coded_samples = bytestream2_get_le32(gb);
539 540
        nb_samples     = (buf_size - (4 + 8 * ch)) * 2 / ch;
        break;
541
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
542
        nb_samples = (buf_size - ch) / ch * 2;
543
        break;
544 545 546
    case AV_CODEC_ID_ADPCM_EA_R1:
    case AV_CODEC_ID_ADPCM_EA_R2:
    case AV_CODEC_ID_ADPCM_EA_R3:
547 548 549 550
        /* maximum number of samples */
        /* has internal offsets and a per-frame switch to signal raw 16-bit */
        has_coded_samples = 1;
        switch (avctx->codec->id) {
551
        case AV_CODEC_ID_ADPCM_EA_R1:
552
            header_size    = 4 + 9 * ch;
553
            *coded_samples = bytestream2_get_le32(gb);
554
            break;
555
        case AV_CODEC_ID_ADPCM_EA_R2:
556
            header_size    = 4 + 5 * ch;
557
            *coded_samples = bytestream2_get_le32(gb);
558
            break;
559
        case AV_CODEC_ID_ADPCM_EA_R3:
560
            header_size    = 4 + 5 * ch;
561
            *coded_samples = bytestream2_get_be32(gb);
562 563 564 565 566
            break;
        }
        *coded_samples -= *coded_samples % 28;
        nb_samples      = (buf_size - header_size) * 2 / ch;
        nb_samples     -= nb_samples % 28;
567
        *approx_nb_samples = 1;
568
        break;
569
    case AV_CODEC_ID_ADPCM_IMA_DK3:
570 571
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
572
        nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
573
        break;
574
    case AV_CODEC_ID_ADPCM_IMA_DK4:
575 576
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
577 578
        nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
        break;
James Almer's avatar
James Almer committed
579 580 581 582 583
    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;
584
    case AV_CODEC_ID_ADPCM_IMA_WAV:
585 586 587
    {
        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];
588 589
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
590
        nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;
591
        break;
592
    }
593
    case AV_CODEC_ID_ADPCM_MS:
594 595 596 597
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
        nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
        break;
598 599 600
    case AV_CODEC_ID_ADPCM_SBPRO_2:
    case AV_CODEC_ID_ADPCM_SBPRO_3:
    case AV_CODEC_ID_ADPCM_SBPRO_4:
601 602 603
    {
        int samples_per_byte;
        switch (avctx->codec->id) {
604 605 606
        case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
        case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
        case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
607 608 609 610 611 612 613 614
        }
        if (!s->status[0].step_index) {
            nb_samples++;
            buf_size -= ch;
        }
        nb_samples += buf_size * samples_per_byte / ch;
        break;
    }
615
    case AV_CODEC_ID_ADPCM_SWF:
616 617
    {
        int buf_bits       = buf_size * 8 - 2;
618
        int nbits          = (bytestream2_get_byte(gb) >> 6) + 2;
619 620 621 622 623 624 625 626 627
        int block_hdr_size = 22 * ch;
        int block_size     = block_hdr_size + nbits * ch * 4095;
        int nblocks        = buf_bits / block_size;
        int bits_left      = buf_bits - nblocks * block_size;
        nb_samples         = nblocks * 4096;
        if (bits_left >= block_hdr_size)
            nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
        break;
    }
628
    case AV_CODEC_ID_ADPCM_THP:
629 630 631 632
        if (avctx->extradata) {
            nb_samples = buf_size / (8 * ch) * 14;
            break;
        }
633
        has_coded_samples = 1;
634 635
        bytestream2_skip(gb, 4); // channel size
        *coded_samples  = bytestream2_get_be32(gb);
636
        *coded_samples -= *coded_samples % 14;
637
        nb_samples      = (buf_size - (8 + 36 * ch)) / (8 * ch) * 14;
638
        break;
Paul B Mahol's avatar
Paul B Mahol committed
639 640 641
    case AV_CODEC_ID_ADPCM_AFC:
        nb_samples = buf_size / (9 * ch) * 16;
        break;
642
    case AV_CODEC_ID_ADPCM_XA:
643 644
        nb_samples = (buf_size / 128) * 224 / ch;
        break;
James Almer's avatar
James Almer committed
645 646 647
    case AV_CODEC_ID_ADPCM_DTK:
        nb_samples = buf_size / (16 * ch) * 28;
        break;
648 649 650 651 652 653 654 655
    }

    /* validate coded sample count */
    if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
        return AVERROR_INVALIDDATA;

    return nb_samples;
}
656

657 658
static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame_ptr, AVPacket *avpkt)
659
{
660
    AVFrame *frame     = data;
661 662
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
663
    ADPCMDecodeContext *c = avctx->priv_data;
664
    ADPCMChannelStatus *cs;
Michael Niedermayer's avatar
Michael Niedermayer committed
665
    int n, m, channel, i;
666
    short *samples;
667
    int16_t **samples_p;
668
    int st; /* stereo */
669
    int count1, count2;
670
    int nb_samples, coded_samples, approx_nb_samples, ret;
671
    GetByteContext gb;
672

673
    bytestream2_init(&gb, buf, buf_size);
674
    nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);
675 676 677 678
    if (nb_samples <= 0) {
        av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
        return AVERROR_INVALIDDATA;
    }
Mike Melanson's avatar
Mike Melanson committed
679

680
    /* get output buffer */
681
    frame->nb_samples = nb_samples;
682
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
683
        return ret;
684 685
    samples = (short *)frame->data[0];
    samples_p = (int16_t **)frame->extended_data;
686

687 688 689
    /* use coded_samples when applicable */
    /* it is always <= nb_samples, so the output buffer will be large enough */
    if (coded_samples) {
690
        if (!approx_nb_samples && coded_samples != nb_samples)
691
            av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
692
        frame->nb_samples = nb_samples = coded_samples;
693
    }
694

695
    st = avctx->channels == 2 ? 1 : 0;
696 697

    switch(avctx->codec->id) {
698
    case AV_CODEC_ID_ADPCM_IMA_QT:
699 700
        /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
           Channel data is interleaved per-chunk. */
701
        for (channel = 0; channel < avctx->channels; channel++) {
702
            int predictor;
703
            int step_index;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
704 705
            cs = &(c->status[channel]);
            /* (pppppp) (piiiiiii) */
706

Baptiste Coudurier's avatar
Baptiste Coudurier committed
707
            /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
708
            predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
709
            step_index = predictor & 0x7F;
710
            predictor &= ~0x7F;
711 712

            if (cs->step_index == step_index) {
713
                int diff = predictor - cs->predictor;
714 715 716 717 718 719 720 721 722
                if (diff < 0)
                    diff = - diff;
                if (diff > 0x7f)
                    goto update;
            } else {
            update:
                cs->step_index = step_index;
                cs->predictor = predictor;
            }
723

724 725 726 727
            if (cs->step_index > 88u){
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
                       channel, cs->step_index);
                return AVERROR_INVALIDDATA;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
728
            }
729

730
            samples = samples_p[channel];
731

732
            for (m = 0; m < 64; m += 2) {
733
                int byte = bytestream2_get_byteu(&gb);
734 735
                samples[m    ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F, 3);
                samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4  , 3);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
736
            }
737 738
        }
        break;
739
    case AV_CODEC_ID_ADPCM_IMA_WAV:
Michael Niedermayer's avatar
Michael Niedermayer committed
740 741
        for(i=0; i<avctx->channels; i++){
            cs = &(c->status[i]);
742
            cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
743

744 745 746 747 748
            cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
            if (cs->step_index > 88u){
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
                       i, cs->step_index);
                return AVERROR_INVALIDDATA;
749
            }
750 751
        }

752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
        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 {
769
        for (n = 0; n < (nb_samples - 1) / 8; n++) {
770 771
            for (i = 0; i < avctx->channels; i++) {
                cs = &c->status[i];
772 773
                samples = &samples_p[i][1 + n * 8];
                for (m = 0; m < 8; m += 2) {
774
                    int v = bytestream2_get_byteu(&gb);
775 776
                    samples[m    ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
                    samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
777
                }
778 779
            }
        }
780
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
781
        break;
782
    case AV_CODEC_ID_ADPCM_4XM:
783
        for (i = 0; i < avctx->channels; i++)
784
            c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
Michael Niedermayer's avatar
Michael Niedermayer committed
785

786
        for (i = 0; i < avctx->channels; i++) {
787 788 789 790 791 792
            c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
            if (c->status[i].step_index > 88u) {
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
                       i, c->status[i].step_index);
                return AVERROR_INVALIDDATA;
            }
793
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
794

795
        for (i = 0; i < avctx->channels; i++) {
796
            samples = (int16_t *)frame->data[i];
797
            cs = &c->status[i];
798 799
            for (n = nb_samples >> 1; n > 0; n--) {
                int v = bytestream2_get_byteu(&gb);
800 801
                *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
                *samples++ = adpcm_ima_expand_nibble(cs, v >> 4  , 4);
802 803
            }
        }
804
        break;
805
    case AV_CODEC_ID_ADPCM_MS:
806 807 808
    {
        int block_predictor;

809 810 811 812 813 814
        block_predictor = bytestream2_get_byteu(&gb);
        if (block_predictor > 6) {
            av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
                   block_predictor);
            return AVERROR_INVALIDDATA;
        }
815 816 817
        c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
        c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
        if (st) {
818 819 820 821 822 823
            block_predictor = bytestream2_get_byteu(&gb);
            if (block_predictor > 6) {
                av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
                       block_predictor);
                return AVERROR_INVALIDDATA;
            }
824 825 826
            c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
            c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
        }
827
        c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
828
        if (st){
829
            c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
830
        }
831

832 833 834 835
        c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
        if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
        c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
        if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
836 837 838

        *samples++ = c->status[0].sample2;
        if (st) *samples++ = c->status[1].sample2;
839 840
        *samples++ = c->status[0].sample1;
        if (st) *samples++ = c->status[1].sample1;
841 842 843 844
        for(n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
            int byte = bytestream2_get_byteu(&gb);
            *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4  );
            *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
845 846
        }
        break;
847
    }
848
    case AV_CODEC_ID_ADPCM_IMA_DK4:
849 850
        for (channel = 0; channel < avctx->channels; channel++) {
            cs = &c->status[channel];
851 852 853 854 855 856 857
            cs->predictor  = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
            cs->step_index = 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;
            }
858
        }
859
        for (n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
860
            int v = bytestream2_get_byteu(&gb);
861 862
            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4  , 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
863 864
        }
        break;
865
    case AV_CODEC_ID_ADPCM_IMA_DK3:
866
    {
867 868
        int last_byte = 0;
        int nibble;
869 870
        int decode_top_nibble_next = 0;
        int diff_channel;
871 872 873 874 875 876 877 878 879 880 881 882
        const int16_t *samples_end = samples + avctx->channels * nb_samples;

        bytestream2_skipu(&gb, 10);
        c->status[0].predictor  = sign_extend(bytestream2_get_le16u(&gb), 16);
        c->status[1].predictor  = sign_extend(bytestream2_get_le16u(&gb), 16);
        c->status[0].step_index = bytestream2_get_byteu(&gb);
        c->status[1].step_index = bytestream2_get_byteu(&gb);
        if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
            av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
                   c->status[0].step_index, c->status[1].step_index);
            return AVERROR_INVALIDDATA;
        }
883 884 885
        /* sign extend the predictors */
        diff_channel = c->status[1].predictor;

886 887 888 889 890 891 892 893 894 895 896 897
        /* DK3 ADPCM support macro */
#define DK3_GET_NEXT_NIBBLE() \
    if (decode_top_nibble_next) { \
        nibble = last_byte >> 4; \
        decode_top_nibble_next = 0; \
    } else { \
        last_byte = bytestream2_get_byteu(&gb); \
        nibble = last_byte & 0x0F; \
        decode_top_nibble_next = 1; \
    }

        while (samples < samples_end) {
898 899 900 901 902 903

            /* for this algorithm, c->status[0] is the sum channel and
             * c->status[1] is the diff channel */

            /* process the first predictor of the sum channel */
            DK3_GET_NEXT_NIBBLE();
Michael Niedermayer's avatar
Michael Niedermayer committed
904
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
905 906 907

            /* process the diff channel predictor */
            DK3_GET_NEXT_NIBBLE();
Michael Niedermayer's avatar
Michael Niedermayer committed
908
            adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
909 910 911 912 913 914 915 916

            /* process the first pair of stereo PCM samples */
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
            *samples++ = c->status[0].predictor + c->status[1].predictor;
            *samples++ = c->status[0].predictor - c->status[1].predictor;

            /* process the second predictor of the sum channel */
            DK3_GET_NEXT_NIBBLE();
Michael Niedermayer's avatar
Michael Niedermayer committed
917
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
918 919 920 921 922 923

            /* process the second pair of stereo PCM samples */
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
            *samples++ = c->status[0].predictor + c->status[1].predictor;
            *samples++ = c->status[0].predictor - c->status[1].predictor;
        }
924 925 926

        if ((bytestream2_tell(&gb) & 1))
            bytestream2_skip(&gb, 1);
927
        break;
928
    }
929
    case AV_CODEC_ID_ADPCM_IMA_ISS:
930 931
        for (channel = 0; channel < avctx->channels; channel++) {
            cs = &c->status[channel];
932 933 934 935 936 937 938
            cs->predictor  = sign_extend(bytestream2_get_le16u(&gb), 16);
            cs->step_index = 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;
            }
939 940
        }

941 942 943
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v1, v2;
            int v = bytestream2_get_byteu(&gb);
944
            /* nibbles are swapped for mono */
945
            if (st) {
946 947
                v1 = v >> 4;
                v2 = v & 0x0F;
948
            } else {
949 950
                v2 = v >> 4;
                v1 = v & 0x0F;
951
            }
952 953
            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
954 955
        }
        break;
956
    case AV_CODEC_ID_ADPCM_IMA_APC:
957 958
        while (bytestream2_get_bytes_left(&gb) > 0) {
            int v = bytestream2_get_byteu(&gb);
959 960
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  v >> 4  , 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
961 962
        }
        break;
963 964 965 966 967 968 969
    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;
James Almer's avatar
James Almer committed
970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994
    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;
995
    case AV_CODEC_ID_ADPCM_IMA_WS:
996 997
        if (c->vqa_version == 3) {
            for (channel = 0; channel < avctx->channels; channel++) {
998
                int16_t *smp = samples_p[channel];
999

1000 1001
                for (n = nb_samples / 2; n > 0; n--) {
                    int v = bytestream2_get_byteu(&gb);
1002 1003
                    *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4  , 3);
                    *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1004
                }
1005
            }
1006
        } else {
1007
            for (n = nb_samples / 2; n > 0; n--) {
1008 1009 1010 1011 1012 1013
                for (channel = 0; channel < avctx->channels; channel++) {
                    int v = bytestream2_get_byteu(&gb);
                    *samples++  = adpcm_ima_expand_nibble(&c->status[channel], v >> 4  , 3);
                    samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
                }
                samples += avctx->channels;
1014 1015
            }
        }
1016
        bytestream2_seek(&gb, 0, SEEK_END);
1017
        break;
1018
    case AV_CODEC_ID_ADPCM_XA:
1019 1020 1021 1022 1023
    {
        int16_t *out0 = samples_p[0];
        int16_t *out1 = samples_p[1];
        int samples_per_block = 28 * (3 - avctx->channels) * 4;
        int sample_offset = 0;
1024
        while (bytestream2_get_bytes_left(&gb) >= 128) {
1025 1026 1027
            if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
                                 &c->status[0], &c->status[1],
                                 avctx->channels, sample_offset)) < 0)
1028
                return ret;
1029
            bytestream2_skipu(&gb, 128);
1030
            sample_offset += samples_per_block;
1031 1032
        }
        break;
1033
    }
1034
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
1035 1036 1037 1038 1039 1040 1041 1042
        for (i=0; i<=st; i++) {
            c->status[i].step_index = bytestream2_get_le32u(&gb);
            if (c->status[i].step_index > 88u) {
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
                       i, c->status[i].step_index);
                return AVERROR_INVALIDDATA;
            }
        }
Peter Ross's avatar
Peter Ross committed
1043
        for (i=0; i<=st; i++)
1044
            c->status[i].predictor  = bytestream2_get_le32u(&gb);
Peter Ross's avatar
Peter Ross committed
1045

1046 1047 1048 1049
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int byte   = bytestream2_get_byteu(&gb);
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  byte >> 4,   3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
Peter Ross's avatar
Peter Ross committed
1050 1051
        }
        break;
1052
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
1053 1054 1055 1056
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int byte = bytestream2_get_byteu(&gb);
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  byte >> 4,   6);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
Peter Ross's avatar
Peter Ross committed
1057 1058
        }
        break;
1059
    case AV_CODEC_ID_ADPCM_EA:
1060
    {
1061 1062 1063 1064 1065
        int previous_left_sample, previous_right_sample;
        int current_left_sample, current_right_sample;
        int next_left_sample, next_right_sample;
        int coeff1l, coeff2l, coeff1r, coeff2r;
        int shift_left, shift_right;
1066

1067 1068
        /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
           each coding 28 stereo samples. */
1069

Michael Niedermayer's avatar
Michael Niedermayer committed
1070 1071 1072
        if(avctx->channels != 2)
            return AVERROR_INVALIDDATA;

1073 1074 1075 1076
        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);
        previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1077

1078
        for (count1 = 0; count1 < nb_samples / 28; count1++) {
1079 1080 1081 1082 1083
            int byte = bytestream2_get_byteu(&gb);
            coeff1l = ea_adpcm_table[ byte >> 4       ];
            coeff2l = ea_adpcm_table[(byte >> 4  ) + 4];
            coeff1r = ea_adpcm_table[ byte & 0x0F];
            coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];
1084

1085 1086 1087
            byte = bytestream2_get_byteu(&gb);
            shift_left  = 20 - (byte >> 4);
            shift_right = 20 - (byte & 0x0F);
1088 1089

            for (count2 = 0; count2 < 28; count2++) {
1090 1091 1092
                byte = bytestream2_get_byteu(&gb);
                next_left_sample  = sign_extend(byte >> 4, 4) << shift_left;
                next_right_sample = sign_extend(byte,      4) << shift_right;
1093

1094 1095
                next_left_sample = (next_left_sample +
                    (current_left_sample * coeff1l) +
1096
                    (previous_left_sample * coeff2l) + 0x80) >> 8;
1097 1098
                next_right_sample = (next_right_sample +
                    (current_right_sample * coeff1r) +
1099 1100 1101
                    (previous_right_sample * coeff2r) + 0x80) >> 8;

                previous_left_sample = current_left_sample;
1102
                current_left_sample = av_clip_int16(next_left_sample);
1103
                previous_right_sample = current_right_sample;
1104
                current_right_sample = av_clip_int16(next_right_sample);
1105 1106
                *samples++ = current_left_sample;
                *samples++ = current_right_sample;
1107 1108
            }
        }
1109

1110
        bytestream2_skip(&gb, 2); // Skip terminating 0x0000
1111

1112
        break;
1113
    }
1114
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
1115 1116 1117
    {
        int coeff[2][2], shift[2];

1118
        for(channel = 0; channel < avctx->channels; channel++) {
1119
            int byte = bytestream2_get_byteu(&gb);
1120
            for (i=0; i<2; i++)
1121 1122
                coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
            shift[channel] = 20 - (byte & 0x0F);
1123
        }
1124
        for (count1 = 0; count1 < nb_samples / 2; count1++) {
1125 1126 1127 1128
            int byte[2];

            byte[0] = bytestream2_get_byteu(&gb);
            if (st) byte[1] = bytestream2_get_byteu(&gb);
1129 1130
            for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
                for(channel = 0; channel < avctx->channels; channel++) {
1131
                    int sample = sign_extend(byte[channel] >> i, 4) << shift[channel];
1132 1133 1134 1135 1136 1137 1138 1139 1140
                    sample = (sample +
                             c->status[channel].sample1 * coeff[channel][0] +
                             c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
                    c->status[channel].sample2 = c->status[channel].sample1;
                    c->status[channel].sample1 = av_clip_int16(sample);
                    *samples++ = c->status[channel].sample1;
                }
            }
        }
1141
        bytestream2_seek(&gb, 0, SEEK_END);
1142
        break;
1143
    }
1144 1145 1146
    case AV_CODEC_ID_ADPCM_EA_R1:
    case AV_CODEC_ID_ADPCM_EA_R2:
    case AV_CODEC_ID_ADPCM_EA_R3: {
1147 1148 1149 1150
        /* channel numbering
           2chan: 0=fl, 1=fr
           4chan: 0=fl, 1=rl, 2=fr, 3=rr
           6chan: 0=fl, 1=c,  2=fr, 3=rl,  4=rr, 5=sub */
1151
        const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1152 1153 1154
        int previous_sample, current_sample, next_sample;
        int coeff1, coeff2;
        int shift;
1155 1156
        unsigned int channel;
        uint16_t *samplesC;
1157
        int count = 0;
1158
        int offsets[6];
1159

1160 1161 1162 1163
        for (channel=0; channel<avctx->channels; channel++)
            offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
                                             bytestream2_get_le32(&gb)) +
                               (avctx->channels + 1) * 4;
1164 1165

        for (channel=0; channel<avctx->channels; channel++) {
1166
            bytestream2_seek(&gb, offsets[channel], SEEK_SET);
1167
            samplesC = samples_p[channel];
1168

1169
            if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1170 1171
                current_sample  = sign_extend(bytestream2_get_le16(&gb), 16);
                previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1172 1173 1174 1175 1176
            } else {
                current_sample  = c->status[channel].predictor;
                previous_sample = c->status[channel].prev_sample;
            }

1177
            for (count1 = 0; count1 < nb_samples / 28; count1++) {
1178 1179 1180 1181
                int byte = bytestream2_get_byte(&gb);
                if (byte == 0xEE) {  /* only seen in R2 and R3 */
                    current_sample  = sign_extend(bytestream2_get_be16(&gb), 16);
                    previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1182

1183 1184
                    for (count2=0; count2<28; count2++)
                        *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
1185
                } else {
1186 1187 1188
                    coeff1 = ea_adpcm_table[ byte >> 4     ];
                    coeff2 = ea_adpcm_table[(byte >> 4) + 4];
                    shift = 20 - (byte & 0x0F);
1189 1190 1191

                    for (count2=0; count2<28; count2++) {
                        if (count2 & 1)
1192 1193 1194 1195 1196
                            next_sample = sign_extend(byte,    4) << shift;
                        else {
                            byte = bytestream2_get_byte(&gb);
                            next_sample = sign_extend(byte >> 4, 4) << shift;
                        }
1197 1198 1199 1200 1201 1202 1203

                        next_sample += (current_sample  * coeff1) +
                                       (previous_sample * coeff2);
                        next_sample = av_clip_int16(next_sample >> 8);

                        previous_sample = current_sample;
                        current_sample  = next_sample;
1204
                        *samplesC++ = current_sample;
1205 1206 1207
                    }
                }
            }
1208 1209 1210 1211 1212 1213
            if (!count) {
                count = count1;
            } else if (count != count1) {
                av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
                count = FFMAX(count, count1);
            }
1214

1215
            if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1216 1217 1218 1219 1220
                c->status[channel].predictor   = current_sample;
                c->status[channel].prev_sample = previous_sample;
            }
        }

1221
        frame->nb_samples = count * 28;
1222
        bytestream2_seek(&gb, 0, SEEK_END);
1223 1224
        break;
    }
1225
    case AV_CODEC_ID_ADPCM_EA_XAS:
1226 1227
        for (channel=0; channel<avctx->channels; channel++) {
            int coeff[2][4], shift[4];
1228 1229
            int16_t *s = samples_p[channel];
            for (n = 0; n < 4; n++, s += 32) {
1230
                int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1231
                for (i=0; i<2; i++)
1232 1233 1234 1235 1236
                    coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];
                s[0] = val & ~0x0F;

                val = sign_extend(bytestream2_get_le16u(&gb), 16);
                shift[n] = 20 - (val & 0x0F);
1237
                s[1] = val & ~0x0F;
1238 1239 1240
            }

            for (m=2; m<32; m+=2) {
1241 1242 1243
                s = &samples_p[channel][m];
                for (n = 0; n < 4; n++, s += 32) {
                    int level, pred;
1244
                    int byte = bytestream2_get_byteu(&gb);
1245 1246 1247 1248 1249 1250 1251 1252

                    level = sign_extend(byte >> 4, 4) << shift[n];
                    pred  = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
                    s[0]  = av_clip_int16((level + pred + 0x80) >> 8);

                    level = sign_extend(byte, 4) << shift[n];
                    pred  = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
                    s[1]  = av_clip_int16((level + pred + 0x80) >> 8);
1253 1254 1255 1256
                }
            }
        }
        break;
1257
    case AV_CODEC_ID_ADPCM_IMA_AMV:
1258 1259 1260
        c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
        c->status[0].step_index = bytestream2_get_le16u(&gb);
        bytestream2_skipu(&gb, 4);
1261 1262 1263 1264
        if (c->status[0].step_index > 88u) {
            av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
                   c->status[0].step_index);
            return AVERROR_INVALIDDATA;
1265
        }
Vitor Sessak's avatar
Vitor Sessak committed
1266

1267
        for (n = nb_samples >> (1 - st); n > 0; n--) {
1268
            int v = bytestream2_get_byteu(&gb);
Vitor Sessak's avatar
Vitor Sessak committed
1269

1270 1271 1272 1273 1274
            *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:
1275
        for (i = 0; i < avctx->channels; i++) {
1276 1277 1278 1279 1280 1281 1282 1283
            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;
            }
1284
        }
1285 1286 1287

        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v = bytestream2_get_byteu(&gb);
Vitor Sessak's avatar
Vitor Sessak committed
1288

1289 1290
            *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4, 3);
            *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf, 3);
1291 1292
        }
        break;
1293
    case AV_CODEC_ID_ADPCM_CT:
1294 1295
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v = bytestream2_get_byteu(&gb);
1296 1297
            *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4  );
            *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1298 1299
        }
        break;
1300 1301 1302
    case AV_CODEC_ID_ADPCM_SBPRO_4:
    case AV_CODEC_ID_ADPCM_SBPRO_3:
    case AV_CODEC_ID_ADPCM_SBPRO_2:
1303 1304
        if (!c->status[0].step_index) {
            /* the first byte is a raw sample */
1305
            *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1306
            if (st)
1307
                *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1308
            c->status[0].step_index = 1;
1309
            nb_samples--;
1310
        }
1311
        if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1312 1313
            for (n = nb_samples >> (1 - st); n > 0; n--) {
                int byte = bytestream2_get_byteu(&gb);
1314
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1315
                                                       byte >> 4,   4, 0);
1316
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1317
                                                       byte & 0x0F, 4, 0);
1318
            }
1319
        } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1320
            for (n = (nb_samples<<st) / 3; n > 0; n--) {
1321
                int byte = bytestream2_get_byteu(&gb);
1322
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1323
                                                        byte >> 5        , 3, 0);
1324
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1325
                                                       (byte >> 2) & 0x07, 3, 0);
1326
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1327
                                                        byte & 0x03,       2, 0);
1328 1329
            }
        } else {
1330 1331
            for (n = nb_samples >> (2 - st); n > 0; n--) {
                int byte = bytestream2_get_byteu(&gb);
1332
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1333
                                                        byte >> 6        , 2, 2);
1334
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1335
                                                       (byte >> 4) & 0x03, 2, 2);
1336
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1337
                                                       (byte >> 2) & 0x03, 2, 2);
1338
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1339
                                                        byte & 0x03,       2, 2);
1340 1341 1342
            }
        }
        break;
1343
    case AV_CODEC_ID_ADPCM_SWF:
1344 1345
        adpcm_swf_decode(avctx, buf, buf_size, samples);
        bytestream2_seek(&gb, 0, SEEK_END);
1346
        break;
1347
    case AV_CODEC_ID_ADPCM_YAMAHA:
1348 1349
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v = bytestream2_get_byteu(&gb);
1350 1351
            *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
            *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4  );
1352 1353
        }
        break;
Paul B Mahol's avatar
Paul B Mahol committed
1354
    case AV_CODEC_ID_ADPCM_AFC:
Paul B Mahol's avatar
Paul B Mahol committed
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
    {
        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++) {
Paul B Mahol's avatar
Paul B Mahol committed
1368 1369 1370 1371
        for (channel = 0; channel < avctx->channels; channel++) {
            int prev1 = c->status[channel].sample1;
            int prev2 = c->status[channel].sample2;

Paul B Mahol's avatar
Paul B Mahol committed
1372
            samples = samples_p[channel] + m * 16;
Paul B Mahol's avatar
Paul B Mahol committed
1373
            /* Read in every sample for this channel.  */
Paul B Mahol's avatar
Paul B Mahol committed
1374
            for (i = 0; i < samples_per_block; i++) {
Paul B Mahol's avatar
Paul B Mahol committed
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
                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;
        }
Paul B Mahol's avatar
Paul B Mahol committed
1403
        }
Paul B Mahol's avatar
Paul B Mahol committed
1404 1405
        bytestream2_seek(&gb, 0, SEEK_END);
        break;
Paul B Mahol's avatar
Paul B Mahol committed
1406
    }
1407
    case AV_CODEC_ID_ADPCM_THP:
1408
    {
1409
        int table[6][16];
1410 1411
        int ch;

1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
        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;
            }

            bytestream2_init(&tb, avctx->extradata, avctx->extradata_size);
            for (i = 0; i < avctx->channels; i++)
                for (n = 0; n < 16; n++)
                    table[i][n] = sign_extend(bytestream2_get_be16u(&tb), 16);
        } else {
1424
        for (i = 0; i < avctx->channels; i++)
1425 1426
            for (n = 0; n < 16; n++)
                table[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16);
1427 1428

        /* Initialize the previous sample.  */
1429
        for (i = 0; i < avctx->channels; i++) {
1430 1431
            c->status[i].sample1 = sign_extend(bytestream2_get_be16u(&gb), 16);
            c->status[i].sample2 = sign_extend(bytestream2_get_be16u(&gb), 16);
1432
        }
1433
        }
1434

1435
        for (ch = 0; ch < avctx->channels; ch++) {
1436
            samples = samples_p[ch];
1437 1438

            /* Read in every sample for this channel.  */
1439
            for (i = 0; i < nb_samples / 14; i++) {
1440 1441 1442
                int byte = bytestream2_get_byteu(&gb);
                int index = (byte >> 4) & 7;
                unsigned int exp = byte & 0x0F;
1443 1444
                int factor1 = table[ch][index * 2];
                int factor2 = table[ch][index * 2 + 1];
1445 1446 1447

                /* Decode 14 samples.  */
                for (n = 0; n < 14; n++) {
1448
                    int32_t sampledat;
1449 1450 1451 1452 1453 1454 1455

                    if (n & 1) {
                        sampledat = sign_extend(byte, 4);
                    } else {
                        byte = bytestream2_get_byteu(&gb);
                        sampledat = sign_extend(byte >> 4, 4);
                    }
1456

1457 1458
                    sampledat = ((c->status[ch].sample1 * factor1
                                + c->status[ch].sample2 * factor2) >> 11) + (sampledat << exp);
1459
                    *samples = av_clip_int16(sampledat);
1460 1461
                    c->status[ch].sample2 = c->status[ch].sample1;
                    c->status[ch].sample1 = *samples++;
1462 1463 1464 1465
                }
            }
        }
        break;
1466
    }
James Almer's avatar
James Almer committed
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
    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((prev + 0x20) >> 6, -0x200000, 0x1fffff);

                    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;
1515

1516 1517 1518
    default:
        return -1;
    }
1519

1520 1521 1522 1523 1524
    if (avpkt->size && bytestream2_tell(&gb) == 0) {
        av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n");
        return AVERROR_INVALIDDATA;
    }

1525
    *got_frame_ptr = 1;
1526

1527
    return bytestream2_tell(&gb);
1528 1529
}

1530

1531 1532
static const enum AVSampleFormat sample_fmts_s16[]  = { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_NONE };
1533
static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16P,
1534
                                                        AV_SAMPLE_FMT_NONE };
1535 1536 1537
static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_S16P,
                                                        AV_SAMPLE_FMT_NONE };
1538 1539

#define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \
1540 1541
AVCodec ff_ ## name_ ## _decoder = {                        \
    .name           = #name_,                               \
1542
    .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
1543 1544 1545 1546 1547
    .type           = AVMEDIA_TYPE_AUDIO,                   \
    .id             = id_,                                  \
    .priv_data_size = sizeof(ADPCMDecodeContext),           \
    .init           = adpcm_decode_init,                    \
    .decode         = adpcm_decode_frame,                   \
1548
    .capabilities   = CODEC_CAP_DR1,                        \
1549
    .sample_fmts    = sample_fmts_,                         \
1550
}
1551

1552
/* Note: Do not forget to add new entries to the Makefile as well. */
1553
ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM,         sample_fmts_s16p, adpcm_4xm,         "ADPCM 4X Movie");
Paul B Mahol's avatar
Paul B Mahol committed
1554
ADPCM_DECODER(AV_CODEC_ID_ADPCM_AFC,         sample_fmts_s16p, adpcm_afc,         "ADPCM Nintendo Gamecube AFC");
1555
ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT,          sample_fmts_s16,  adpcm_ct,          "ADPCM Creative Technology");
James Almer's avatar
James Almer committed
1556
ADPCM_DECODER(AV_CODEC_ID_ADPCM_DTK,         sample_fmts_s16p, adpcm_dtk,         "ADPCM Nintendo Gamecube DTK");
1557 1558
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");
1559 1560 1561
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1,       sample_fmts_s16p, adpcm_ea_r1,       "ADPCM Electronic Arts R1");
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R2,       sample_fmts_s16p, adpcm_ea_r2,       "ADPCM Electronic Arts R2");
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R3,       sample_fmts_s16p, adpcm_ea_r3,       "ADPCM Electronic Arts R3");
1562
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS,      sample_fmts_s16p, adpcm_ea_xas,      "ADPCM Electronic Arts XAS");
1563 1564 1565 1566 1567 1568 1569
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_AMV,     sample_fmts_s16,  adpcm_ima_amv,     "ADPCM IMA AMV");
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APC,     sample_fmts_s16,  adpcm_ima_apc,     "ADPCM IMA CRYO APC");
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK3,     sample_fmts_s16,  adpcm_ima_dk3,     "ADPCM IMA Duck DK3");
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4,     sample_fmts_s16,  adpcm_ima_dk4,     "ADPCM IMA Duck 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");
1570
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_OKI,     sample_fmts_s16,  adpcm_ima_oki,     "ADPCM IMA Dialogic OKI");
1571
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT,      sample_fmts_s16p, adpcm_ima_qt,      "ADPCM IMA QuickTime");
James Almer's avatar
James Almer committed
1572
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_RAD,     sample_fmts_s16,  adpcm_ima_rad,     "ADPCM IMA Radical");
1573
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG,  sample_fmts_s16,  adpcm_ima_smjpeg,  "ADPCM IMA Loki SDL MJPEG");
1574
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV,     sample_fmts_s16p, adpcm_ima_wav,     "ADPCM IMA WAV");
1575
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS,      sample_fmts_both, adpcm_ima_ws,      "ADPCM IMA Westwood");
1576 1577 1578 1579 1580
ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS,          sample_fmts_s16,  adpcm_ms,          "ADPCM Microsoft");
ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2,     sample_fmts_s16,  adpcm_sbpro_2,     "ADPCM Sound Blaster Pro 2-bit");
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");
1581
ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP,         sample_fmts_s16p, adpcm_thp,         "ADPCM Nintendo Gamecube THP");
1582
ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA,          sample_fmts_s16p, adpcm_xa,          "ADPCM CDROM XA");
1583
ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA,      sample_fmts_s16,  adpcm_yamaha,      "ADPCM Yamaha");