adpcm.c 50.7 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
 * This file is part of Libav.
17
 *
18
 * Libav 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
 * Libav 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 Libav; 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 "put_bits.h"
35
#include "bytestream.h"
36 37
#include "adpcm.h"
#include "adpcm_data.h"
38
#include "internal.h"
39

Michael Niedermayer's avatar
Michael Niedermayer committed
40
/**
41
 * @file
42
 * ADPCM decoders
43 44 45
 * Features and limitations:
 *
 * Reference documents:
46 47 48 49 50 51 52
 * 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/
53 54
 *
 * CD-ROM XA:
55 56
 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html [dead]
 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html [dead]
57
 * readstr http://www.geocities.co.jp/Playtown/2004/
58 59
 */

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

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

77
// padded to zero where table size is less then 16
Michael Niedermayer's avatar
Michael Niedermayer committed
78
static const int swf_index_tables[4][16] = {
79 80 81 82 83 84
    /*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 }
};

85 86
/* end of tables */

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

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

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

114
    switch(avctx->codec->id) {
115
    case AV_CODEC_ID_ADPCM_CT:
116 117
        c->status[0].step = c->status[1].step = 511;
        break;
118
    case AV_CODEC_ID_ADPCM_IMA_WAV:
119 120 121 122 123
        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;
        }
        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:
148 149
            avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
            break;
150 151 152 153
        case AV_CODEC_ID_ADPCM_IMA_WS:
            avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
                                                      AV_SAMPLE_FMT_S16;
            break;
154 155 156
        default:
            avctx->sample_fmt = AV_SAMPLE_FMT_S16;
    }
157

158 159 160
    return 0;
}

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

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

    sign = nibble & 8;
    delta = nibble & 7;
173 174 175
    /* 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
176
    diff = ((2 * delta + 1) * step) >> shift;
Michael Niedermayer's avatar
Michael Niedermayer committed
177 178 179 180
    predictor = c->predictor;
    if (sign) predictor -= diff;
    else predictor += diff;

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

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

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 212
static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
{
    int step_index;
    int predictor;
    int diff, step;

    step = ff_adpcm_step_table[c->step_index];
    step_index = c->step_index + ff_adpcm_index_table[nibble];
    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;
}

213
static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
214 215 216
{
    int predictor;

217
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
218
    predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
219 220

    c->sample2 = c->sample1;
221
    c->sample1 = av_clip_int16(predictor);
222
    c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
223 224
    if (c->idelta < 16) c->idelta = 16;

225
    return c->sample1;
226 227
}

228 229 230 231 232 233 234 235 236 237 238 239
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 */
240 241
    c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
    c->predictor = av_clip_int16(c->predictor);
242
    /* calculate new step and clamp it to range 511..32767 */
243
    new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
244
    c->step = av_clip(new_step, 511, 32767);
245

246
    return (short)c->predictor;
247 248
}

249 250 251 252 253 254 255 256 257
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 */
258
    c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
259 260 261 262 263 264 265 266 267 268

    /* 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;
}

269 270 271 272 273 274 275
static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
{
    if(!c->step) {
        c->predictor = 0;
        c->step = 127;
    }

276
    c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
277
    c->predictor = av_clip_int16(c->predictor);
278
    c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
279
    c->step = av_clip(c->step, 127, 24567);
280 281 282
    return c->predictor;
}

283 284 285
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)
286 287 288 289 290 291
{
    int i, j;
    int shift,filter,f0,f1;
    int s_1,s_2;
    int d,s,t;

292 293 294 295 296
    out0 += sample_offset;
    if (channels == 1)
        out1 = out0 + 28;
    else
        out1 += sample_offset;
297

298
    for(i=0;i<4;i++) {
299 300
        shift  = 12 - (in[4+i*2] & 15);
        filter = in[4+i*2] >> 4;
301 302 303 304 305 306
        if (filter > 4) {
            av_log(avctx, AV_LOG_ERROR,
                   "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
                   filter);
            return AVERROR_INVALIDDATA;
        }
307 308 309 310 311 312 313 314 315
        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];

316
            t = sign_extend(d, 4);
317 318
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
            s_2 = s_1;
319
            s_1 = av_clip_int16(s);
320
            out0[j] = s_1;
321 322
        }

323
        if (channels == 2) {
324 325 326 327 328 329 330 331
            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;
332 333 334 335 336 337
        if (filter > 4) {
            av_log(avctx, AV_LOG_ERROR,
                   "Invalid XA-ADPCM filter %d (max. allowed is 4)\n",
                   filter);
            return AVERROR_INVALIDDATA;
        }
338 339 340 341 342 343
        f0 = xa_adpcm_table[filter][0];
        f1 = xa_adpcm_table[filter][1];

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

344
            t = sign_extend(d >> 4, 4);
345 346
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
            s_2 = s_1;
347
            s_1 = av_clip_int16(s);
348
            out1[j] = s_1;
349 350
        }

351
        if (channels == 2) {
352 353 354 355 356 357
            right->sample1 = s_1;
            right->sample2 = s_2;
        } else {
            left->sample1 = s_1;
            left->sample2 = s_2;
        }
358 359 360

        out0 += 28 * (3 - channels);
        out1 += 28 * (3 - channels);
361
    }
362 363

    return 0;
364 365
}

366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
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;
            }
        }
    }
}

423 424 425 426 427 428 429 430 431
/**
 * 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.
 */
432
static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
433 434 435 436 437 438 439 440 441 442 443 444
                          int buf_size, int *coded_samples)
{
    ADPCMDecodeContext *s = avctx->priv_data;
    int nb_samples        = 0;
    int ch                = avctx->channels;
    int has_coded_samples = 0;
    int header_size;

    *coded_samples = 0;

    switch (avctx->codec->id) {
    /* constant, only check buf_size */
445
    case AV_CODEC_ID_ADPCM_EA_XAS:
446 447 448 449
        if (buf_size < 76 * ch)
            return 0;
        nb_samples = 128;
        break;
450
    case AV_CODEC_ID_ADPCM_IMA_QT:
451 452 453 454 455
        if (buf_size < 34 * ch)
            return 0;
        nb_samples = 64;
        break;
    /* simple 4-bit adpcm */
456 457 458 459 460
    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_WS:
    case AV_CODEC_ID_ADPCM_YAMAHA:
461 462 463 464 465 466 467 468 469
        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) {
470 471 472 473
        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;
474 475 476 477 478 479
    }
    if (header_size > 0)
        return (buf_size - header_size) * 2 / ch;

    /* more complex formats */
    switch (avctx->codec->id) {
480
    case AV_CODEC_ID_ADPCM_EA:
481
        has_coded_samples = 1;
482
        *coded_samples  = bytestream2_get_le32(gb);
483 484 485
        *coded_samples -= *coded_samples % 28;
        nb_samples      = (buf_size - 12) / 30 * 28;
        break;
486
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
487
        has_coded_samples = 1;
488
        *coded_samples = bytestream2_get_le32(gb);
489 490
        nb_samples     = (buf_size - (4 + 8 * ch)) * 2 / ch;
        break;
491
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
492
        nb_samples = (buf_size - ch) / ch * 2;
493
        break;
494 495 496
    case AV_CODEC_ID_ADPCM_EA_R1:
    case AV_CODEC_ID_ADPCM_EA_R2:
    case AV_CODEC_ID_ADPCM_EA_R3:
497 498 499 500
        /* 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) {
501
        case AV_CODEC_ID_ADPCM_EA_R1:
502
            header_size    = 4 + 9 * ch;
503
            *coded_samples = bytestream2_get_le32(gb);
504
            break;
505
        case AV_CODEC_ID_ADPCM_EA_R2:
506
            header_size    = 4 + 5 * ch;
507
            *coded_samples = bytestream2_get_le32(gb);
508
            break;
509
        case AV_CODEC_ID_ADPCM_EA_R3:
510
            header_size    = 4 + 5 * ch;
511
            *coded_samples = bytestream2_get_be32(gb);
512 513 514 515 516 517
            break;
        }
        *coded_samples -= *coded_samples % 28;
        nb_samples      = (buf_size - header_size) * 2 / ch;
        nb_samples     -= nb_samples % 28;
        break;
518
    case AV_CODEC_ID_ADPCM_IMA_DK3:
519 520
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
521
        nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
522
        break;
523
    case AV_CODEC_ID_ADPCM_IMA_DK4:
524 525
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
526 527
        nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
        break;
528
    case AV_CODEC_ID_ADPCM_IMA_WAV:
529 530 531 532
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
        nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8;
        break;
533
    case AV_CODEC_ID_ADPCM_MS:
534 535 536 537
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
        nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
        break;
538 539 540
    case AV_CODEC_ID_ADPCM_SBPRO_2:
    case AV_CODEC_ID_ADPCM_SBPRO_3:
    case AV_CODEC_ID_ADPCM_SBPRO_4:
541 542 543
    {
        int samples_per_byte;
        switch (avctx->codec->id) {
544 545 546
        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;
547 548 549 550 551 552 553 554
        }
        if (!s->status[0].step_index) {
            nb_samples++;
            buf_size -= ch;
        }
        nb_samples += buf_size * samples_per_byte / ch;
        break;
    }
555
    case AV_CODEC_ID_ADPCM_SWF:
556 557
    {
        int buf_bits       = buf_size * 8 - 2;
558
        int nbits          = (bytestream2_get_byte(gb) >> 6) + 2;
559 560 561 562 563 564 565 566 567
        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;
    }
568
    case AV_CODEC_ID_ADPCM_THP:
569
        has_coded_samples = 1;
570 571
        bytestream2_skip(gb, 4); // channel size
        *coded_samples  = bytestream2_get_be32(gb);
572 573 574
        *coded_samples -= *coded_samples % 14;
        nb_samples      = (buf_size - 80) / (8 * ch) * 14;
        break;
575
    case AV_CODEC_ID_ADPCM_XA:
576 577 578 579 580 581 582 583 584 585
        nb_samples = (buf_size / 128) * 224 / ch;
        break;
    }

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

    return nb_samples;
}
586

587 588
static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame_ptr, AVPacket *avpkt)
589
{
590
    AVFrame *frame     = data;
591 592
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
593
    ADPCMDecodeContext *c = avctx->priv_data;
594
    ADPCMChannelStatus *cs;
Michael Niedermayer's avatar
Michael Niedermayer committed
595
    int n, m, channel, i;
596
    short *samples;
597
    int16_t **samples_p;
598
    int st; /* stereo */
599
    int count1, count2;
600
    int nb_samples, coded_samples, ret;
601
    GetByteContext gb;
602

603
    bytestream2_init(&gb, buf, buf_size);
604
    nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples);
605 606 607 608 609
    if (nb_samples <= 0) {
        av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
        return AVERROR_INVALIDDATA;
    }

610
    /* get output buffer */
611
    frame->nb_samples = nb_samples;
612
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
613 614
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
        return ret;
615
    }
616 617
    samples = (short *)frame->data[0];
    samples_p = (int16_t **)frame->extended_data;
618

619 620 621 622 623
    /* 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)
            av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
624
        frame->nb_samples = nb_samples = coded_samples;
625
    }
626

627
    st = avctx->channels == 2 ? 1 : 0;
628 629

    switch(avctx->codec->id) {
630
    case AV_CODEC_ID_ADPCM_IMA_QT:
631 632
        /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
           Channel data is interleaved per-chunk. */
633
        for (channel = 0; channel < avctx->channels; channel++) {
634
            int predictor;
635
            int step_index;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
636 637
            cs = &(c->status[channel]);
            /* (pppppp) (piiiiiii) */
638

Baptiste Coudurier's avatar
Baptiste Coudurier committed
639
            /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
640
            predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
641
            step_index = predictor & 0x7F;
642
            predictor &= ~0x7F;
643 644

            if (cs->step_index == step_index) {
645
                int diff = predictor - cs->predictor;
646 647 648 649 650 651 652 653 654
                if (diff < 0)
                    diff = - diff;
                if (diff > 0x7f)
                    goto update;
            } else {
            update:
                cs->step_index = step_index;
                cs->predictor = predictor;
            }
655

656 657 658 659
            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
660
            }
661

662
            samples = samples_p[channel];
663

664
            for (m = 0; m < 64; m += 2) {
665
                int byte = bytestream2_get_byteu(&gb);
666 667
                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
668
            }
669 670
        }
        break;
671
    case AV_CODEC_ID_ADPCM_IMA_WAV:
Michael Niedermayer's avatar
Michael Niedermayer committed
672 673
        for(i=0; i<avctx->channels; i++){
            cs = &(c->status[i]);
674
            cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
675

676 677 678 679 680
            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;
681
            }
682 683
        }

684
        for (n = 0; n < (nb_samples - 1) / 8; n++) {
685 686
            for (i = 0; i < avctx->channels; i++) {
                cs = &c->status[i];
687 688
                samples = &samples_p[i][1 + n * 8];
                for (m = 0; m < 8; m += 2) {
689
                    int v = bytestream2_get_byteu(&gb);
690 691
                    samples[m    ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
                    samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
692
                }
693 694
            }
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
695
        break;
696
    case AV_CODEC_ID_ADPCM_4XM:
697
        for (i = 0; i < avctx->channels; i++)
698
            c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
Michael Niedermayer's avatar
Michael Niedermayer committed
699

700
        for (i = 0; i < avctx->channels; i++) {
701 702 703 704 705 706
            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;
            }
707
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
708

709
        for (i = 0; i < avctx->channels; i++) {
710
            samples = (int16_t *)frame->data[i];
711
            cs = &c->status[i];
712 713
            for (n = nb_samples >> 1; n > 0; n--) {
                int v = bytestream2_get_byteu(&gb);
714 715
                *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
                *samples++ = adpcm_ima_expand_nibble(cs, v >> 4  , 4);
716 717
            }
        }
718
        break;
719
    case AV_CODEC_ID_ADPCM_MS:
720 721 722
    {
        int block_predictor;

723 724 725 726 727 728
        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;
        }
729 730 731
        c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
        c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
        if (st) {
732 733 734 735 736 737
            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;
            }
738 739 740
            c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
            c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
        }
741
        c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
742
        if (st){
743
            c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
744
        }
745

746 747 748 749
        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);
750 751 752

        *samples++ = c->status[0].sample2;
        if (st) *samples++ = c->status[1].sample2;
753 754
        *samples++ = c->status[0].sample1;
        if (st) *samples++ = c->status[1].sample1;
755 756 757 758
        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);
759 760
        }
        break;
761
    }
762
    case AV_CODEC_ID_ADPCM_IMA_DK4:
763 764
        for (channel = 0; channel < avctx->channels; channel++) {
            cs = &c->status[channel];
765 766 767 768 769 770 771
            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;
            }
772
        }
773
        for (n = (nb_samples >> (1 - st)) - 1; n > 0; n--) {
774
            int v = bytestream2_get_byteu(&gb);
775 776
            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4  , 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
777 778
        }
        break;
779
    case AV_CODEC_ID_ADPCM_IMA_DK3:
780
    {
781 782
        int last_byte = 0;
        int nibble;
783 784
        int decode_top_nibble_next = 0;
        int diff_channel;
785 786 787 788 789 790 791 792 793 794 795 796
        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;
        }
797 798 799
        /* sign extend the predictors */
        diff_channel = c->status[1].predictor;

800 801 802 803 804 805 806 807 808 809 810 811
        /* 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) {
812 813 814 815 816 817

            /* 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
818
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
819 820 821

            /* process the diff channel predictor */
            DK3_GET_NEXT_NIBBLE();
Michael Niedermayer's avatar
Michael Niedermayer committed
822
            adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
823 824 825 826 827 828 829 830

            /* 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
831
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
832 833 834 835 836 837 838

            /* 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;
        }
        break;
839
    }
840
    case AV_CODEC_ID_ADPCM_IMA_ISS:
841 842
        for (channel = 0; channel < avctx->channels; channel++) {
            cs = &c->status[channel];
843 844 845 846 847 848 849
            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;
            }
850 851
        }

852 853 854
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v1, v2;
            int v = bytestream2_get_byteu(&gb);
855
            /* nibbles are swapped for mono */
856
            if (st) {
857 858
                v1 = v >> 4;
                v2 = v & 0x0F;
859
            } else {
860 861
                v2 = v >> 4;
                v1 = v & 0x0F;
862
            }
863 864
            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
865 866
        }
        break;
867
    case AV_CODEC_ID_ADPCM_IMA_APC:
868 869
        while (bytestream2_get_bytes_left(&gb) > 0) {
            int v = bytestream2_get_byteu(&gb);
870 871
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  v >> 4  , 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
872 873
        }
        break;
874
    case AV_CODEC_ID_ADPCM_IMA_WS:
875 876
        if (c->vqa_version == 3) {
            for (channel = 0; channel < avctx->channels; channel++) {
877
                int16_t *smp = samples_p[channel];
878

879 880
                for (n = nb_samples / 2; n > 0; n--) {
                    int v = bytestream2_get_byteu(&gb);
881 882
                    *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4  , 3);
                    *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
883
                }
884
            }
885
        } else {
886
            for (n = nb_samples / 2; n > 0; n--) {
887 888 889 890 891 892
                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;
893 894
            }
        }
895
        bytestream2_seek(&gb, 0, SEEK_END);
896
        break;
897
    case AV_CODEC_ID_ADPCM_XA:
898 899 900 901 902
    {
        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;
903
        while (bytestream2_get_bytes_left(&gb) >= 128) {
904 905 906
            if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
                                 &c->status[0], &c->status[1],
                                 avctx->channels, sample_offset)) < 0)
907
                return ret;
908
            bytestream2_skipu(&gb, 128);
909
            sample_offset += samples_per_block;
910 911
        }
        break;
912
    }
913
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
914 915 916 917 918 919 920 921
        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
922
        for (i=0; i<=st; i++)
923
            c->status[i].predictor  = bytestream2_get_le32u(&gb);
Peter Ross's avatar
Peter Ross committed
924

925 926 927 928
        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
929 930
        }
        break;
931
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
932 933 934 935
        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
936 937
        }
        break;
938
    case AV_CODEC_ID_ADPCM_EA:
939
    {
940 941 942 943 944
        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;
945

946 947
        /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
           each coding 28 stereo samples. */
948

949 950 951 952
        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);
953

954
        for (count1 = 0; count1 < nb_samples / 28; count1++) {
955 956 957 958 959
            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];
960

961 962 963
            byte = bytestream2_get_byteu(&gb);
            shift_left  = 20 - (byte >> 4);
            shift_right = 20 - (byte & 0x0F);
964 965

            for (count2 = 0; count2 < 28; count2++) {
966 967 968
                byte = bytestream2_get_byteu(&gb);
                next_left_sample  = sign_extend(byte >> 4, 4) << shift_left;
                next_right_sample = sign_extend(byte,      4) << shift_right;
969

970 971
                next_left_sample = (next_left_sample +
                    (current_left_sample * coeff1l) +
972
                    (previous_left_sample * coeff2l) + 0x80) >> 8;
973 974
                next_right_sample = (next_right_sample +
                    (current_right_sample * coeff1r) +
975 976 977
                    (previous_right_sample * coeff2r) + 0x80) >> 8;

                previous_left_sample = current_left_sample;
978
                current_left_sample = av_clip_int16(next_left_sample);
979
                previous_right_sample = current_right_sample;
980
                current_right_sample = av_clip_int16(next_right_sample);
981 982
                *samples++ = current_left_sample;
                *samples++ = current_right_sample;
983 984
            }
        }
985

986
        bytestream2_skip(&gb, 2); // Skip terminating 0x0000
987

988
        break;
989
    }
990
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
991 992 993
    {
        int coeff[2][2], shift[2];

994
        for(channel = 0; channel < avctx->channels; channel++) {
995
            int byte = bytestream2_get_byteu(&gb);
996
            for (i=0; i<2; i++)
997 998
                coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
            shift[channel] = 20 - (byte & 0x0F);
999
        }
1000
        for (count1 = 0; count1 < nb_samples / 2; count1++) {
1001 1002 1003 1004
            int byte[2];

            byte[0] = bytestream2_get_byteu(&gb);
            if (st) byte[1] = bytestream2_get_byteu(&gb);
1005 1006
            for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
                for(channel = 0; channel < avctx->channels; channel++) {
1007
                    int sample = sign_extend(byte[channel] >> i, 4) << shift[channel];
1008 1009 1010 1011 1012 1013 1014 1015 1016
                    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;
                }
            }
        }
1017
        bytestream2_seek(&gb, 0, SEEK_END);
1018
        break;
1019
    }
1020 1021 1022
    case AV_CODEC_ID_ADPCM_EA_R1:
    case AV_CODEC_ID_ADPCM_EA_R2:
    case AV_CODEC_ID_ADPCM_EA_R3: {
1023 1024 1025 1026
        /* 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 */
1027
        const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1028 1029 1030
        int previous_sample, current_sample, next_sample;
        int coeff1, coeff2;
        int shift;
1031 1032
        unsigned int channel;
        uint16_t *samplesC;
1033
        int count = 0;
1034
        int offsets[6];
1035

1036 1037 1038 1039
        for (channel=0; channel<avctx->channels; channel++)
            offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
                                             bytestream2_get_le32(&gb)) +
                               (avctx->channels + 1) * 4;
1040 1041

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

1045
            if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1046 1047
                current_sample  = sign_extend(bytestream2_get_le16(&gb), 16);
                previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1048 1049 1050 1051 1052
            } else {
                current_sample  = c->status[channel].predictor;
                previous_sample = c->status[channel].prev_sample;
            }

1053
            for (count1 = 0; count1 < nb_samples / 28; count1++) {
1054 1055 1056 1057
                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);
1058

1059 1060
                    for (count2=0; count2<28; count2++)
                        *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
1061
                } else {
1062 1063 1064
                    coeff1 = ea_adpcm_table[ byte >> 4     ];
                    coeff2 = ea_adpcm_table[(byte >> 4) + 4];
                    shift = 20 - (byte & 0x0F);
1065 1066 1067

                    for (count2=0; count2<28; count2++) {
                        if (count2 & 1)
1068 1069 1070 1071 1072
                            next_sample = sign_extend(byte,    4) << shift;
                        else {
                            byte = bytestream2_get_byte(&gb);
                            next_sample = sign_extend(byte >> 4, 4) << shift;
                        }
1073 1074 1075 1076 1077 1078 1079

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

                        previous_sample = current_sample;
                        current_sample  = next_sample;
1080
                        *samplesC++ = current_sample;
1081 1082 1083
                    }
                }
            }
1084 1085 1086 1087 1088 1089
            if (!count) {
                count = count1;
            } else if (count != count1) {
                av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
                count = FFMAX(count, count1);
            }
1090

1091
            if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1092 1093 1094 1095 1096
                c->status[channel].predictor   = current_sample;
                c->status[channel].prev_sample = previous_sample;
            }
        }

1097
        frame->nb_samples = count * 28;
1098
        bytestream2_seek(&gb, 0, SEEK_END);
1099 1100
        break;
    }
1101
    case AV_CODEC_ID_ADPCM_EA_XAS:
1102 1103
        for (channel=0; channel<avctx->channels; channel++) {
            int coeff[2][4], shift[4];
1104 1105
            int16_t *s = samples_p[channel];
            for (n = 0; n < 4; n++, s += 32) {
1106
                int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1107
                for (i=0; i<2; i++)
1108 1109 1110 1111 1112
                    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);
1113
                s[1] = val & ~0x0F;
1114 1115 1116
            }

            for (m=2; m<32; m+=2) {
1117 1118 1119
                s = &samples_p[channel][m];
                for (n = 0; n < 4; n++, s += 32) {
                    int level, pred;
1120
                    int byte = bytestream2_get_byteu(&gb);
1121 1122 1123 1124 1125 1126 1127 1128

                    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);
1129 1130 1131 1132
                }
            }
        }
        break;
1133 1134 1135
    case AV_CODEC_ID_ADPCM_IMA_AMV:
    case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
        if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
1136 1137 1138
            c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
            c->status[0].step_index = bytestream2_get_le16u(&gb);
            bytestream2_skipu(&gb, 4);
1139
        } else {
1140 1141 1142 1143 1144 1145 1146 1147
            c->status[0].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
            c->status[0].step_index = bytestream2_get_byteu(&gb);
            bytestream2_skipu(&gb, 1);
        }
        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;
1148
        }
Vitor Sessak's avatar
Vitor Sessak committed
1149

1150 1151
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int hi, lo, v = bytestream2_get_byteu(&gb);
Vitor Sessak's avatar
Vitor Sessak committed
1152

1153
            if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
1154 1155 1156 1157 1158 1159
                hi = v & 0x0F;
                lo = v >> 4;
            } else {
                lo = v & 0x0F;
                hi = v >> 4;
            }
Vitor Sessak's avatar
Vitor Sessak committed
1160

1161 1162
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], lo, 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], hi, 3);
1163 1164
        }
        break;
1165
    case AV_CODEC_ID_ADPCM_CT:
1166 1167
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v = bytestream2_get_byteu(&gb);
1168 1169
            *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4  );
            *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1170 1171
        }
        break;
1172 1173 1174
    case AV_CODEC_ID_ADPCM_SBPRO_4:
    case AV_CODEC_ID_ADPCM_SBPRO_3:
    case AV_CODEC_ID_ADPCM_SBPRO_2:
1175 1176
        if (!c->status[0].step_index) {
            /* the first byte is a raw sample */
1177
            *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1178
            if (st)
1179
                *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1180
            c->status[0].step_index = 1;
1181
            nb_samples--;
1182
        }
1183
        if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1184 1185
            for (n = nb_samples >> (1 - st); n > 0; n--) {
                int byte = bytestream2_get_byteu(&gb);
1186
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1187
                                                       byte >> 4,   4, 0);
1188
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1189
                                                       byte & 0x0F, 4, 0);
1190
            }
1191
        } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1192 1193
            for (n = nb_samples / 3; n > 0; n--) {
                int byte = bytestream2_get_byteu(&gb);
1194
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1195
                                                        byte >> 5        , 3, 0);
1196
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1197
                                                       (byte >> 2) & 0x07, 3, 0);
1198
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1199
                                                        byte & 0x03,       2, 0);
1200 1201
            }
        } else {
1202 1203
            for (n = nb_samples >> (2 - st); n > 0; n--) {
                int byte = bytestream2_get_byteu(&gb);
1204
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1205
                                                        byte >> 6        , 2, 2);
1206
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1207
                                                       (byte >> 4) & 0x03, 2, 2);
1208
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1209
                                                       (byte >> 2) & 0x03, 2, 2);
1210
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1211
                                                        byte & 0x03,       2, 2);
1212 1213 1214
            }
        }
        break;
1215
    case AV_CODEC_ID_ADPCM_SWF:
1216 1217
        adpcm_swf_decode(avctx, buf, buf_size, samples);
        bytestream2_seek(&gb, 0, SEEK_END);
1218
        break;
1219
    case AV_CODEC_ID_ADPCM_YAMAHA:
1220 1221
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v = bytestream2_get_byteu(&gb);
1222 1223
            *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
            *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4  );
1224 1225
        }
        break;
1226
    case AV_CODEC_ID_ADPCM_THP:
1227
    {
1228
        int table[2][16];
Michael Niedermayer's avatar
Michael Niedermayer committed
1229
        int prev[2][2];
1230 1231
        int ch;

1232 1233 1234
        for (i = 0; i < 2; i++)
            for (n = 0; n < 16; n++)
                table[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16);
1235 1236

        /* Initialize the previous sample.  */
1237 1238 1239
        for (i = 0; i < 2; i++)
            for (n = 0; n < 2; n++)
                prev[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16);
1240 1241

        for (ch = 0; ch <= st; ch++) {
1242
            samples = samples_p[ch];
1243 1244

            /* Read in every sample for this channel.  */
1245
            for (i = 0; i < nb_samples / 14; i++) {
1246 1247 1248
                int byte = bytestream2_get_byteu(&gb);
                int index = (byte >> 4) & 7;
                unsigned int exp = byte & 0x0F;
1249 1250
                int factor1 = table[ch][index * 2];
                int factor2 = table[ch][index * 2 + 1];
1251 1252 1253

                /* Decode 14 samples.  */
                for (n = 0; n < 14; n++) {
1254
                    int32_t sampledat;
1255 1256 1257 1258 1259 1260 1261

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

1263
                    sampledat = ((prev[ch][0]*factor1
Mans Rullgard's avatar
Mans Rullgard committed
1264
                                + prev[ch][1]*factor2) >> 11) + (sampledat << exp);
1265
                    *samples = av_clip_int16(sampledat);
Michael Niedermayer's avatar
Michael Niedermayer committed
1266 1267
                    prev[ch][1] = prev[ch][0];
                    prev[ch][0] = *samples++;
1268 1269 1270 1271
                }
            }
        }
        break;
1272
    }
1273

1274 1275 1276
    default:
        return -1;
    }
1277

1278
    *got_frame_ptr = 1;
1279

1280
    return bytestream2_tell(&gb);
1281 1282
}

1283

1284 1285
static const enum AVSampleFormat sample_fmts_s16[]  = { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_NONE };
1286 1287
static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_NONE };
1288 1289 1290
static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_S16P,
                                                        AV_SAMPLE_FMT_NONE };
1291 1292

#define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \
1293 1294
AVCodec ff_ ## name_ ## _decoder = {                        \
    .name           = #name_,                               \
1295
    .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
1296 1297 1298 1299 1300
    .type           = AVMEDIA_TYPE_AUDIO,                   \
    .id             = id_,                                  \
    .priv_data_size = sizeof(ADPCMDecodeContext),           \
    .init           = adpcm_decode_init,                    \
    .decode         = adpcm_decode_frame,                   \
1301
    .capabilities   = AV_CODEC_CAP_DR1,                     \
1302
    .sample_fmts    = sample_fmts_,                         \
1303
}
1304

1305
/* Note: Do not forget to add new entries to the Makefile as well. */
1306
ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM,         sample_fmts_s16p, adpcm_4xm,         "ADPCM 4X Movie");
1307 1308 1309
ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT,          sample_fmts_s16,  adpcm_ct,          "ADPCM Creative Technology");
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");
1310 1311 1312
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");
1313
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS,      sample_fmts_s16p, adpcm_ea_xas,      "ADPCM Electronic Arts XAS");
1314 1315 1316 1317 1318 1319 1320
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");
1321
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT,      sample_fmts_s16p, adpcm_ima_qt,      "ADPCM IMA QuickTime");
1322
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG,  sample_fmts_s16,  adpcm_ima_smjpeg,  "ADPCM IMA Loki SDL MJPEG");
1323
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV,     sample_fmts_s16p, adpcm_ima_wav,     "ADPCM IMA WAV");
1324
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS,      sample_fmts_both, adpcm_ima_ws,      "ADPCM IMA Westwood");
1325 1326 1327 1328 1329
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");
1330
ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP,         sample_fmts_s16p, adpcm_thp,         "ADPCM Nintendo Gamecube THP");
1331
ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA,          sample_fmts_s16p, adpcm_xa,          "ADPCM CDROM XA");
1332
ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA,      sample_fmts_s16,  adpcm_yamaha,      "ADPCM Yamaha");