adpcm.c 67.8 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[14];
88
    int vqa_version;                /**< VQA version. Used for ADPCM_IMA_WS */
89
    int has_status;
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) {
James Almer's avatar
James Almer committed
99
    case AV_CODEC_ID_ADPCM_DTK:
100
    case AV_CODEC_ID_ADPCM_EA:
101 102
        min_channels = 2;
        break;
103
    case AV_CODEC_ID_ADPCM_AFC:
104 105 106 107
    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:
108 109
        max_channels = 6;
        break;
110 111 112 113
    case AV_CODEC_ID_ADPCM_MTAF:
        min_channels = 2;
        max_channels = 8;
        break;
114 115 116
    case AV_CODEC_ID_ADPCM_PSX:
        max_channels = 8;
        break;
117
    case AV_CODEC_ID_ADPCM_IMA_DAT4:
118
    case AV_CODEC_ID_ADPCM_THP:
119
    case AV_CODEC_ID_ADPCM_THP_LE:
120
        max_channels = 14;
121 122
        break;
    }
123
    if (avctx->channels < min_channels || avctx->channels > max_channels) {
124 125
        av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
        return AVERROR(EINVAL);
126 127
    }

128
    switch(avctx->codec->id) {
129
    case AV_CODEC_ID_ADPCM_CT:
130 131
        c->status[0].step = c->status[1].step = 511;
        break;
132
    case AV_CODEC_ID_ADPCM_IMA_WAV:
133 134
        if (avctx->bits_per_coded_sample < 2 || avctx->bits_per_coded_sample > 5)
            return AVERROR_INVALIDDATA;
135
        break;
136
    case AV_CODEC_ID_ADPCM_IMA_APC:
137
        if (avctx->extradata && avctx->extradata_size >= 8) {
Anssi Hannula's avatar
Anssi Hannula committed
138 139 140 141
            c->status[0].predictor = AV_RL32(avctx->extradata);
            c->status[1].predictor = AV_RL32(avctx->extradata + 4);
        }
        break;
142
    case AV_CODEC_ID_ADPCM_IMA_WS:
143
        if (avctx->extradata && avctx->extradata_size >= 2)
144 145
            c->vqa_version = AV_RL16(avctx->extradata);
        break;
146 147 148
    default:
        break;
    }
149 150

    switch(avctx->codec->id) {
151
        case AV_CODEC_ID_ADPCM_AICA:
152
        case AV_CODEC_ID_ADPCM_IMA_DAT4:
153
        case AV_CODEC_ID_ADPCM_IMA_QT:
154
        case AV_CODEC_ID_ADPCM_IMA_WAV:
155
        case AV_CODEC_ID_ADPCM_4XM:
156
        case AV_CODEC_ID_ADPCM_XA:
157 158 159
        case AV_CODEC_ID_ADPCM_EA_R1:
        case AV_CODEC_ID_ADPCM_EA_R2:
        case AV_CODEC_ID_ADPCM_EA_R3:
160
        case AV_CODEC_ID_ADPCM_EA_XAS:
161
        case AV_CODEC_ID_ADPCM_THP:
162
        case AV_CODEC_ID_ADPCM_THP_LE:
Paul B Mahol's avatar
Paul B Mahol committed
163
        case AV_CODEC_ID_ADPCM_AFC:
James Almer's avatar
James Almer committed
164
        case AV_CODEC_ID_ADPCM_DTK:
165
        case AV_CODEC_ID_ADPCM_PSX:
166
        case AV_CODEC_ID_ADPCM_MTAF:
167 168
            avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
            break;
169 170 171 172
        case AV_CODEC_ID_ADPCM_IMA_WS:
            avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
                                                      AV_SAMPLE_FMT_S16;
            break;
173 174 175
        default:
            avctx->sample_fmt = AV_SAMPLE_FMT_S16;
    }
176

177 178 179
    return 0;
}

180
static inline int16_t adpcm_ima_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
181 182 183 184 185
{
    int step_index;
    int predictor;
    int sign, delta, diff, step;

186 187
    step = ff_adpcm_step_table[c->step_index];
    step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
188
    step_index = av_clip(step_index, 0, 88);
189 190 191

    sign = nibble & 8;
    delta = nibble & 7;
192 193 194
    /* 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
195
    diff = ((2 * delta + 1) * step) >> shift;
Michael Niedermayer's avatar
Michael Niedermayer committed
196 197 198 199
    predictor = c->predictor;
    if (sign) predictor -= diff;
    else predictor += diff;

200
    c->predictor = av_clip_int16(predictor);
Michael Niedermayer's avatar
Michael Niedermayer committed
201 202
    c->step_index = step_index;

203
    return (int16_t)c->predictor;
Michael Niedermayer's avatar
Michael Niedermayer committed
204 205
}

206 207 208 209 210 211 212 213 214 215 216
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);
217
    delta = av_mod_uintp2(nibble, shift);
218 219 220 221 222 223 224 225 226 227 228
    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;
}

229 230 231 232 233 234
static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
{
    int step_index;
    int predictor;
    int diff, step;

235 236
    step = ff_adpcm_step_table[c->step_index];
    step_index = c->step_index + ff_adpcm_index_table[nibble];
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
    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;
}

255
static inline int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
256 257 258
{
    int predictor;

259
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
260
    predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
261 262

    c->sample2 = c->sample1;
263
    c->sample1 = av_clip_int16(predictor);
264
    c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
265
    if (c->idelta < 16) c->idelta = 16;
266 267 268 269
    if (c->idelta > INT_MAX/768) {
        av_log(NULL, AV_LOG_WARNING, "idelta overflow\n");
        c->idelta = INT_MAX/768;
    }
270

271
    return c->sample1;
272 273
}

274
static inline int16_t adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)
275 276 277 278 279 280 281 282 283 284 285 286 287 288
{
    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;

289
    c->predictor = av_clip_intp2(predictor, 11);
290 291 292 293 294
    c->step_index = step_index;

    return c->predictor << 4;
}

295
static inline int16_t adpcm_ct_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
296 297 298 299 300 301 302 303 304 305 306
{
    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 */
307 308
    c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
    c->predictor = av_clip_int16(c->predictor);
309
    /* calculate new step and clamp it to range 511..32767 */
310
    new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
311
    c->step = av_clip(new_step, 511, 32767);
312

313
    return (int16_t)c->predictor;
314 315
}

316
static inline int16_t adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int size, int shift)
317 318 319 320 321 322 323 324
{
    int sign, delta, diff;

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

    /* clamp result */
325
    c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
326 327 328 329 330 331 332

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

333
    return (int16_t) c->predictor;
334 335
}

336
static inline int16_t adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
337 338 339 340 341 342
{
    if(!c->step) {
        c->predictor = 0;
        c->step = 127;
    }

343
    c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
344
    c->predictor = av_clip_int16(c->predictor);
345
    c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
346
    c->step = av_clip(c->step, 127, 24567);
347 348 349
    return c->predictor;
}

350 351 352 353 354 355 356 357 358
static inline int16_t adpcm_mtaf_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
{
    c->predictor += ff_adpcm_mtaf_stepsize[c->step][nibble];
    c->predictor = av_clip_int16(c->predictor);
    c->step += ff_adpcm_index_table[nibble];
    c->step = av_clip_uintp2(c->step, 5);
    return c->predictor;
}

359 360 361
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)
362 363 364 365 366 367
{
    int i, j;
    int shift,filter,f0,f1;
    int s_1,s_2;
    int d,s,t;

368 369 370 371 372
    out0 += sample_offset;
    if (channels == 1)
        out1 = out0 + 28;
    else
        out1 += sample_offset;
373

374
    for(i=0;i<4;i++) {
375 376
        shift  = 12 - (in[4+i*2] & 15);
        filter = in[4+i*2] >> 4;
377
        if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
378
            avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
379 380
            filter=0;
        }
381 382 383 384 385 386 387 388 389
        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];

390
            t = sign_extend(d, 4);
391 392
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
            s_2 = s_1;
393
            s_1 = av_clip_int16(s);
394
            out0[j] = s_1;
395 396
        }

397
        if (channels == 2) {
398 399 400 401 402 403 404 405
            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;
406
        if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
407
            avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
408 409
            filter=0;
        }
410 411 412 413 414 415 416

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

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

417
            t = sign_extend(d >> 4, 4);
418 419
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
            s_2 = s_1;
420
            s_1 = av_clip_int16(s);
421
            out1[j] = s_1;
422 423
        }

424
        if (channels == 2) {
425 426 427 428 429 430
            right->sample1 = s_1;
            right->sample2 = s_2;
        } else {
            left->sample1 = s_1;
            left->sample2 = s_2;
        }
431 432 433

        out0 += 28 * (3 - channels);
        out1 += 28 * (3 - channels);
434
    }
435 436

    return 0;
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 466 467 468
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];
469
                int vpdiff = 0; // vpdiff = (delta+0.5)*step/4
470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
                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;
            }
        }
    }
}

496 497 498 499 500 501 502 503
/**
 * 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.
504 505
 * @param[out] approx_nb_samples set to non-zero if the number of samples
 *                               returned is an approximation.
506
 */
507
static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
508
                          int buf_size, int *coded_samples, int *approx_nb_samples)
509 510 511 512 513 514 515 516
{
    ADPCMDecodeContext *s = avctx->priv_data;
    int nb_samples        = 0;
    int ch                = avctx->channels;
    int has_coded_samples = 0;
    int header_size;

    *coded_samples = 0;
517
    *approx_nb_samples = 0;
518

519 520 521
    if(ch <= 0)
        return 0;

522 523
    switch (avctx->codec->id) {
    /* constant, only check buf_size */
524
    case AV_CODEC_ID_ADPCM_EA_XAS:
525 526 527 528
        if (buf_size < 76 * ch)
            return 0;
        nb_samples = 128;
        break;
529
    case AV_CODEC_ID_ADPCM_IMA_QT:
530 531 532 533 534
        if (buf_size < 34 * ch)
            return 0;
        nb_samples = 64;
        break;
    /* simple 4-bit adpcm */
535 536 537
    case AV_CODEC_ID_ADPCM_CT:
    case AV_CODEC_ID_ADPCM_IMA_APC:
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
538
    case AV_CODEC_ID_ADPCM_IMA_OKI:
539 540
    case AV_CODEC_ID_ADPCM_IMA_WS:
    case AV_CODEC_ID_ADPCM_YAMAHA:
541
    case AV_CODEC_ID_ADPCM_AICA:
542 543 544 545 546 547 548 549 550
        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) {
551
        case AV_CODEC_ID_ADPCM_4XM:
552
        case AV_CODEC_ID_ADPCM_IMA_DAT4:
553 554
        case AV_CODEC_ID_ADPCM_IMA_ISS:     header_size = 4 * ch;      break;
        case AV_CODEC_ID_ADPCM_IMA_AMV:     header_size = 8;           break;
555
        case AV_CODEC_ID_ADPCM_IMA_SMJPEG:  header_size = 4 * ch;      break;
556 557 558 559 560 561
    }
    if (header_size > 0)
        return (buf_size - header_size) * 2 / ch;

    /* more complex formats */
    switch (avctx->codec->id) {
562
    case AV_CODEC_ID_ADPCM_EA:
563
        has_coded_samples = 1;
564
        *coded_samples  = bytestream2_get_le32(gb);
565 566 567
        *coded_samples -= *coded_samples % 28;
        nb_samples      = (buf_size - 12) / 30 * 28;
        break;
568
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
569
        has_coded_samples = 1;
570
        *coded_samples = bytestream2_get_le32(gb);
571 572
        nb_samples     = (buf_size - (4 + 8 * ch)) * 2 / ch;
        break;
573
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
574
        nb_samples = (buf_size - ch) / ch * 2;
575
        break;
576 577 578
    case AV_CODEC_ID_ADPCM_EA_R1:
    case AV_CODEC_ID_ADPCM_EA_R2:
    case AV_CODEC_ID_ADPCM_EA_R3:
579 580 581 582
        /* 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) {
583
        case AV_CODEC_ID_ADPCM_EA_R1:
584
            header_size    = 4 + 9 * ch;
585
            *coded_samples = bytestream2_get_le32(gb);
586
            break;
587
        case AV_CODEC_ID_ADPCM_EA_R2:
588
            header_size    = 4 + 5 * ch;
589
            *coded_samples = bytestream2_get_le32(gb);
590
            break;
591
        case AV_CODEC_ID_ADPCM_EA_R3:
592
            header_size    = 4 + 5 * ch;
593
            *coded_samples = bytestream2_get_be32(gb);
594 595 596 597 598
            break;
        }
        *coded_samples -= *coded_samples % 28;
        nb_samples      = (buf_size - header_size) * 2 / ch;
        nb_samples     -= nb_samples % 28;
599
        *approx_nb_samples = 1;
600
        break;
601
    case AV_CODEC_ID_ADPCM_IMA_DK3:
602 603
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
604
        nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
605
        break;
606
    case AV_CODEC_ID_ADPCM_IMA_DK4:
607 608
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
609 610
        if (buf_size < 4 * ch)
            return AVERROR_INVALIDDATA;
611 612
        nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
        break;
James Almer's avatar
James Almer committed
613 614 615 616 617
    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;
618
    case AV_CODEC_ID_ADPCM_IMA_WAV:
619 620 621
    {
        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];
622 623
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
624 625
        if (buf_size < 4 * ch)
            return AVERROR_INVALIDDATA;
626
        nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;
627
        break;
628
    }
629
    case AV_CODEC_ID_ADPCM_MS:
630 631
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
632
        nb_samples = (buf_size - 6 * ch) * 2 / ch;
633
        break;
634 635 636 637 638
    case AV_CODEC_ID_ADPCM_MTAF:
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
        nb_samples = (buf_size - 16 * (ch / 2)) * 2 / ch;
        break;
639 640 641
    case AV_CODEC_ID_ADPCM_SBPRO_2:
    case AV_CODEC_ID_ADPCM_SBPRO_3:
    case AV_CODEC_ID_ADPCM_SBPRO_4:
642 643 644
    {
        int samples_per_byte;
        switch (avctx->codec->id) {
645 646 647
        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;
648 649
        }
        if (!s->status[0].step_index) {
650 651
            if (buf_size < ch)
                return AVERROR_INVALIDDATA;
652 653 654 655 656 657
            nb_samples++;
            buf_size -= ch;
        }
        nb_samples += buf_size * samples_per_byte / ch;
        break;
    }
658
    case AV_CODEC_ID_ADPCM_SWF:
659 660
    {
        int buf_bits       = buf_size * 8 - 2;
661
        int nbits          = (bytestream2_get_byte(gb) >> 6) + 2;
662 663 664 665 666 667 668 669 670
        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;
    }
671
    case AV_CODEC_ID_ADPCM_THP:
672
    case AV_CODEC_ID_ADPCM_THP_LE:
673
        if (avctx->extradata) {
674
            nb_samples = buf_size * 14 / (8 * ch);
675 676
            break;
        }
677
        has_coded_samples = 1;
678
        bytestream2_skip(gb, 4); // channel size
679 680 681
        *coded_samples  = (avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE) ?
                          bytestream2_get_le32(gb) :
                          bytestream2_get_be32(gb);
682 683 684
        buf_size       -= 8 + 36 * ch;
        buf_size       /= ch;
        nb_samples      = buf_size / 8 * 14;
685
        if (buf_size % 8 > 1)
686
            nb_samples     += (buf_size % 8 - 1) * 2;
687
        *approx_nb_samples = 1;
688
        break;
Paul B Mahol's avatar
Paul B Mahol committed
689 690 691
    case AV_CODEC_ID_ADPCM_AFC:
        nb_samples = buf_size / (9 * ch) * 16;
        break;
692
    case AV_CODEC_ID_ADPCM_XA:
693 694
        nb_samples = (buf_size / 128) * 224 / ch;
        break;
James Almer's avatar
James Almer committed
695
    case AV_CODEC_ID_ADPCM_DTK:
696
    case AV_CODEC_ID_ADPCM_PSX:
James Almer's avatar
James Almer committed
697 698
        nb_samples = buf_size / (16 * ch) * 28;
        break;
699 700 701 702 703 704 705 706
    }

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

    return nb_samples;
}
707

708 709
static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame_ptr, AVPacket *avpkt)
710
{
711
    AVFrame *frame     = data;
712 713
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
714
    ADPCMDecodeContext *c = avctx->priv_data;
715
    ADPCMChannelStatus *cs;
Michael Niedermayer's avatar
Michael Niedermayer committed
716
    int n, m, channel, i;
717
    int16_t *samples;
718
    int16_t **samples_p;
719
    int st; /* stereo */
720
    int count1, count2;
721
    int nb_samples, coded_samples, approx_nb_samples, ret;
722
    GetByteContext gb;
723

724
    bytestream2_init(&gb, buf, buf_size);
725
    nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);
726 727 728 729
    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
730

731
    /* get output buffer */
732
    frame->nb_samples = nb_samples;
733
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
734
        return ret;
735
    samples = (int16_t *)frame->data[0];
736
    samples_p = (int16_t **)frame->extended_data;
737

738 739 740
    /* use coded_samples when applicable */
    /* it is always <= nb_samples, so the output buffer will be large enough */
    if (coded_samples) {
741
        if (!approx_nb_samples && coded_samples != nb_samples)
742
            av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
743
        frame->nb_samples = nb_samples = coded_samples;
744
    }
745

746
    st = avctx->channels == 2 ? 1 : 0;
747 748

    switch(avctx->codec->id) {
749
    case AV_CODEC_ID_ADPCM_IMA_QT:
750 751
        /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
           Channel data is interleaved per-chunk. */
752
        for (channel = 0; channel < avctx->channels; channel++) {
753
            int predictor;
754
            int step_index;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
755 756
            cs = &(c->status[channel]);
            /* (pppppp) (piiiiiii) */
757

Baptiste Coudurier's avatar
Baptiste Coudurier committed
758
            /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
759
            predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
760
            step_index = predictor & 0x7F;
761
            predictor &= ~0x7F;
762 763

            if (cs->step_index == step_index) {
764
                int diff = predictor - cs->predictor;
765 766 767 768 769 770 771 772 773
                if (diff < 0)
                    diff = - diff;
                if (diff > 0x7f)
                    goto update;
            } else {
            update:
                cs->step_index = step_index;
                cs->predictor = predictor;
            }
774

775 776 777 778
            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
779
            }
780

781
            samples = samples_p[channel];
782

783
            for (m = 0; m < 64; m += 2) {
784
                int byte = bytestream2_get_byteu(&gb);
785 786
                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
787
            }
788 789
        }
        break;
790
    case AV_CODEC_ID_ADPCM_IMA_WAV:
Michael Niedermayer's avatar
Michael Niedermayer committed
791 792
        for(i=0; i<avctx->channels; i++){
            cs = &(c->status[i]);
793
            cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
794

795 796 797 798 799
            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;
800
            }
801 802
        }

803 804
        if (avctx->bits_per_coded_sample != 4) {
            int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
805 806
            int block_size = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
            uint8_t temp[20] = { 0 };
807 808 809 810
            GetBitContext g;

            for (n = 0; n < (nb_samples - 1) / samples_per_block; n++) {
                for (i = 0; i < avctx->channels; i++) {
811 812
                    int j;

813 814
                    cs = &c->status[i];
                    samples = &samples_p[i][1 + n * samples_per_block];
815 816 817 818 819 820 821
                    for (j = 0; j < block_size; j++) {
                        temp[j] = buf[4 * avctx->channels + block_size * n * avctx->channels +
                                        (j % 4) + (j / 4) * (avctx->channels * 4) + i * 4];
                    }
                    ret = init_get_bits8(&g, (const uint8_t *)&temp, block_size);
                    if (ret < 0)
                        return ret;
822 823 824 825 826 827 828 829
                    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 {
830
        for (n = 0; n < (nb_samples - 1) / 8; n++) {
831 832
            for (i = 0; i < avctx->channels; i++) {
                cs = &c->status[i];
833 834
                samples = &samples_p[i][1 + n * 8];
                for (m = 0; m < 8; m += 2) {
835
                    int v = bytestream2_get_byteu(&gb);
836 837
                    samples[m    ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
                    samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
838
                }
839 840
            }
        }
841
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
842
        break;
843
    case AV_CODEC_ID_ADPCM_4XM:
844
        for (i = 0; i < avctx->channels; i++)
845
            c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
Michael Niedermayer's avatar
Michael Niedermayer committed
846

847
        for (i = 0; i < avctx->channels; i++) {
848 849 850 851 852 853
            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;
            }
854
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
855

856
        for (i = 0; i < avctx->channels; i++) {
857
            samples = (int16_t *)frame->data[i];
858
            cs = &c->status[i];
859 860
            for (n = nb_samples >> 1; n > 0; n--) {
                int v = bytestream2_get_byteu(&gb);
861 862
                *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
                *samples++ = adpcm_ima_expand_nibble(cs, v >> 4  , 4);
863 864
            }
        }
865
        break;
866
    case AV_CODEC_ID_ADPCM_MS:
867 868 869
    {
        int block_predictor;

870 871 872 873 874 875
        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;
        }
876 877 878
        c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
        c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
        if (st) {
879 880 881 882 883 884
            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;
            }
885 886 887
            c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
            c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
        }
888
        c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
889
        if (st){
890
            c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
891
        }
892

893 894 895 896
        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);
897 898 899

        *samples++ = c->status[0].sample2;
        if (st) *samples++ = c->status[1].sample2;
900 901
        *samples++ = c->status[0].sample1;
        if (st) *samples++ = c->status[1].sample1;
902 903 904 905
        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);
906 907
        }
        break;
908
    }
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
    case AV_CODEC_ID_ADPCM_MTAF:
        for (channel = 0; channel < avctx->channels; channel+=2) {
            bytestream2_skipu(&gb, 4);
            c->status[channel    ].step      = bytestream2_get_le16u(&gb);
            c->status[channel + 1].step      = bytestream2_get_le16u(&gb);
            c->status[channel    ].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
            bytestream2_skipu(&gb, 2);
            c->status[channel + 1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
            bytestream2_skipu(&gb, 2);
            for (n = 0; n < nb_samples; n+=2) {
                int v = bytestream2_get_byteu(&gb);
                samples_p[channel][n    ] = adpcm_mtaf_expand_nibble(&c->status[channel], v & 0x0F);
                samples_p[channel][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel], v >> 4  );
            }
            for (n = 0; n < nb_samples; n+=2) {
                int v = bytestream2_get_byteu(&gb);
                samples_p[channel + 1][n    ] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v & 0x0F);
                samples_p[channel + 1][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v >> 4  );
            }
        }
        break;
930
    case AV_CODEC_ID_ADPCM_IMA_DK4:
931 932
        for (channel = 0; channel < avctx->channels; channel++) {
            cs = &c->status[channel];
933 934 935 936 937 938 939
            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;
            }
940
        }
941
        for (n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
942
            int v = bytestream2_get_byteu(&gb);
943 944
            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4  , 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
945 946
        }
        break;
947
    case AV_CODEC_ID_ADPCM_IMA_DK3:
948
    {
949 950
        int last_byte = 0;
        int nibble;
951 952
        int decode_top_nibble_next = 0;
        int diff_channel;
953 954 955 956 957 958 959 960 961 962 963 964
        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;
        }
965 966 967
        /* sign extend the predictors */
        diff_channel = c->status[1].predictor;

968 969 970 971 972 973 974 975 976 977 978 979
        /* 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) {
980 981 982 983 984 985

            /* 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
986
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
987 988 989

            /* process the diff channel predictor */
            DK3_GET_NEXT_NIBBLE();
Michael Niedermayer's avatar
Michael Niedermayer committed
990
            adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
991 992 993 994 995 996 997 998

            /* 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
999
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1000 1001 1002 1003 1004 1005

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

        if ((bytestream2_tell(&gb) & 1))
            bytestream2_skip(&gb, 1);
1009
        break;
1010
    }
1011
    case AV_CODEC_ID_ADPCM_IMA_ISS:
1012 1013
        for (channel = 0; channel < avctx->channels; channel++) {
            cs = &c->status[channel];
1014 1015 1016 1017 1018 1019 1020
            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;
            }
1021 1022
        }

1023 1024 1025
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v1, v2;
            int v = bytestream2_get_byteu(&gb);
1026
            /* nibbles are swapped for mono */
1027
            if (st) {
1028 1029
                v1 = v >> 4;
                v2 = v & 0x0F;
1030
            } else {
1031 1032
                v2 = v >> 4;
                v1 = v & 0x0F;
1033
            }
1034 1035
            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
1036 1037
        }
        break;
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
    case AV_CODEC_ID_ADPCM_IMA_DAT4:
        for (channel = 0; channel < avctx->channels; channel++) {
            cs = &c->status[channel];
            samples = samples_p[channel];
            bytestream2_skip(&gb, 4);
            for (n = 0; n < nb_samples; n += 2) {
                int v = bytestream2_get_byteu(&gb);
                *samples++ = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
                *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
            }
        }
        break;
1050
    case AV_CODEC_ID_ADPCM_IMA_APC:
1051 1052
        while (bytestream2_get_bytes_left(&gb) > 0) {
            int v = bytestream2_get_byteu(&gb);
1053 1054
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  v >> 4  , 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1055 1056
        }
        break;
1057 1058 1059 1060 1061 1062 1063
    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
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088
    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;
1089
    case AV_CODEC_ID_ADPCM_IMA_WS:
1090 1091
        if (c->vqa_version == 3) {
            for (channel = 0; channel < avctx->channels; channel++) {
1092
                int16_t *smp = samples_p[channel];
1093

1094 1095
                for (n = nb_samples / 2; n > 0; n--) {
                    int v = bytestream2_get_byteu(&gb);
1096 1097
                    *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4  , 3);
                    *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1098
                }
1099
            }
1100
        } else {
1101
            for (n = nb_samples / 2; n > 0; n--) {
1102 1103 1104 1105 1106 1107
                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;
1108 1109
            }
        }
1110
        bytestream2_seek(&gb, 0, SEEK_END);
1111
        break;
1112
    case AV_CODEC_ID_ADPCM_XA:
1113 1114 1115 1116 1117
    {
        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;
1118
        while (bytestream2_get_bytes_left(&gb) >= 128) {
1119 1120 1121
            if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
                                 &c->status[0], &c->status[1],
                                 avctx->channels, sample_offset)) < 0)
1122
                return ret;
1123
            bytestream2_skipu(&gb, 128);
1124
            sample_offset += samples_per_block;
1125 1126
        }
        break;
1127
    }
1128
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
1129 1130 1131 1132 1133 1134 1135 1136
        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
1137
        for (i=0; i<=st; i++)
1138
            c->status[i].predictor  = bytestream2_get_le32u(&gb);
Peter Ross's avatar
Peter Ross committed
1139

1140 1141 1142 1143
        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
1144 1145
        }
        break;
1146
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
1147 1148 1149 1150
        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
1151 1152
        }
        break;
1153
    case AV_CODEC_ID_ADPCM_EA:
1154
    {
1155 1156 1157 1158 1159
        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;
1160

1161 1162
        /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
           each coding 28 stereo samples. */
1163

Michael Niedermayer's avatar
Michael Niedermayer committed
1164 1165 1166
        if(avctx->channels != 2)
            return AVERROR_INVALIDDATA;

1167 1168 1169 1170
        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);
1171

1172
        for (count1 = 0; count1 < nb_samples / 28; count1++) {
1173 1174 1175 1176 1177
            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];
1178

1179 1180 1181
            byte = bytestream2_get_byteu(&gb);
            shift_left  = 20 - (byte >> 4);
            shift_right = 20 - (byte & 0x0F);
1182 1183

            for (count2 = 0; count2 < 28; count2++) {
1184 1185 1186
                byte = bytestream2_get_byteu(&gb);
                next_left_sample  = sign_extend(byte >> 4, 4) << shift_left;
                next_right_sample = sign_extend(byte,      4) << shift_right;
1187

1188 1189
                next_left_sample = (next_left_sample +
                    (current_left_sample * coeff1l) +
1190
                    (previous_left_sample * coeff2l) + 0x80) >> 8;
1191 1192
                next_right_sample = (next_right_sample +
                    (current_right_sample * coeff1r) +
1193 1194 1195
                    (previous_right_sample * coeff2r) + 0x80) >> 8;

                previous_left_sample = current_left_sample;
1196
                current_left_sample = av_clip_int16(next_left_sample);
1197
                previous_right_sample = current_right_sample;
1198
                current_right_sample = av_clip_int16(next_right_sample);
1199 1200
                *samples++ = current_left_sample;
                *samples++ = current_right_sample;
1201 1202
            }
        }
1203

1204
        bytestream2_skip(&gb, 2); // Skip terminating 0x0000
1205

1206
        break;
1207
    }
1208
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
1209 1210 1211
    {
        int coeff[2][2], shift[2];

1212
        for(channel = 0; channel < avctx->channels; channel++) {
1213
            int byte = bytestream2_get_byteu(&gb);
1214
            for (i=0; i<2; i++)
1215 1216
                coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
            shift[channel] = 20 - (byte & 0x0F);
1217
        }
1218
        for (count1 = 0; count1 < nb_samples / 2; count1++) {
1219 1220 1221 1222
            int byte[2];

            byte[0] = bytestream2_get_byteu(&gb);
            if (st) byte[1] = bytestream2_get_byteu(&gb);
1223 1224
            for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
                for(channel = 0; channel < avctx->channels; channel++) {
1225
                    int sample = sign_extend(byte[channel] >> i, 4) << shift[channel];
1226 1227 1228 1229 1230 1231 1232 1233 1234
                    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;
                }
            }
        }
1235
        bytestream2_seek(&gb, 0, SEEK_END);
1236
        break;
1237
    }
1238 1239 1240
    case AV_CODEC_ID_ADPCM_EA_R1:
    case AV_CODEC_ID_ADPCM_EA_R2:
    case AV_CODEC_ID_ADPCM_EA_R3: {
1241 1242 1243 1244
        /* 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 */
1245
        const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1246 1247 1248
        int previous_sample, current_sample, next_sample;
        int coeff1, coeff2;
        int shift;
1249 1250
        unsigned int channel;
        uint16_t *samplesC;
1251
        int count = 0;
1252
        int offsets[6];
1253

1254 1255 1256 1257
        for (channel=0; channel<avctx->channels; channel++)
            offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
                                             bytestream2_get_le32(&gb)) +
                               (avctx->channels + 1) * 4;
1258 1259

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

1263
            if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1264 1265
                current_sample  = sign_extend(bytestream2_get_le16(&gb), 16);
                previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1266 1267 1268 1269 1270
            } else {
                current_sample  = c->status[channel].predictor;
                previous_sample = c->status[channel].prev_sample;
            }

1271
            for (count1 = 0; count1 < nb_samples / 28; count1++) {
1272 1273 1274 1275
                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);
1276

1277 1278
                    for (count2=0; count2<28; count2++)
                        *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
1279
                } else {
1280 1281 1282
                    coeff1 = ea_adpcm_table[ byte >> 4     ];
                    coeff2 = ea_adpcm_table[(byte >> 4) + 4];
                    shift = 20 - (byte & 0x0F);
1283 1284 1285

                    for (count2=0; count2<28; count2++) {
                        if (count2 & 1)
1286 1287 1288 1289 1290
                            next_sample = sign_extend(byte,    4) << shift;
                        else {
                            byte = bytestream2_get_byte(&gb);
                            next_sample = sign_extend(byte >> 4, 4) << shift;
                        }
1291 1292 1293 1294 1295 1296 1297

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

                        previous_sample = current_sample;
                        current_sample  = next_sample;
1298
                        *samplesC++ = current_sample;
1299 1300 1301
                    }
                }
            }
1302 1303 1304 1305 1306 1307
            if (!count) {
                count = count1;
            } else if (count != count1) {
                av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
                count = FFMAX(count, count1);
            }
1308

1309
            if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1310 1311 1312 1313 1314
                c->status[channel].predictor   = current_sample;
                c->status[channel].prev_sample = previous_sample;
            }
        }

1315
        frame->nb_samples = count * 28;
1316
        bytestream2_seek(&gb, 0, SEEK_END);
1317 1318
        break;
    }
1319
    case AV_CODEC_ID_ADPCM_EA_XAS:
1320 1321
        for (channel=0; channel<avctx->channels; channel++) {
            int coeff[2][4], shift[4];
1322 1323
            int16_t *s = samples_p[channel];
            for (n = 0; n < 4; n++, s += 32) {
1324
                int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1325
                for (i=0; i<2; i++)
1326 1327 1328 1329 1330
                    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);
1331
                s[1] = val & ~0x0F;
1332 1333 1334
            }

            for (m=2; m<32; m+=2) {
1335 1336 1337
                s = &samples_p[channel][m];
                for (n = 0; n < 4; n++, s += 32) {
                    int level, pred;
1338
                    int byte = bytestream2_get_byteu(&gb);
1339 1340 1341 1342 1343 1344 1345 1346

                    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);
1347 1348 1349 1350
                }
            }
        }
        break;
1351
    case AV_CODEC_ID_ADPCM_IMA_AMV:
1352
        c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1353 1354
        c->status[0].step_index = bytestream2_get_byteu(&gb);
        bytestream2_skipu(&gb, 5);
1355 1356 1357 1358
        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;
1359
        }
Vitor Sessak's avatar
Vitor Sessak committed
1360

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

1364 1365 1366 1367 1368
            *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:
1369
        for (i = 0; i < avctx->channels; i++) {
1370 1371 1372 1373 1374 1375 1376 1377
            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;
            }
1378
        }
1379 1380 1381

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

1383 1384
            *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4, 3);
            *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf, 3);
1385 1386
        }
        break;
1387
    case AV_CODEC_ID_ADPCM_CT:
1388 1389
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v = bytestream2_get_byteu(&gb);
1390 1391
            *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4  );
            *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1392 1393
        }
        break;
1394 1395 1396
    case AV_CODEC_ID_ADPCM_SBPRO_4:
    case AV_CODEC_ID_ADPCM_SBPRO_3:
    case AV_CODEC_ID_ADPCM_SBPRO_2:
1397 1398
        if (!c->status[0].step_index) {
            /* the first byte is a raw sample */
1399
            *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1400
            if (st)
1401
                *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1402
            c->status[0].step_index = 1;
1403
            nb_samples--;
1404
        }
1405
        if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1406 1407
            for (n = nb_samples >> (1 - st); n > 0; n--) {
                int byte = bytestream2_get_byteu(&gb);
1408
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1409
                                                       byte >> 4,   4, 0);
1410
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1411
                                                       byte & 0x0F, 4, 0);
1412
            }
1413
        } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1414
            for (n = (nb_samples<<st) / 3; n > 0; n--) {
1415
                int byte = bytestream2_get_byteu(&gb);
1416
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1417
                                                        byte >> 5        , 3, 0);
1418
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1419
                                                       (byte >> 2) & 0x07, 3, 0);
1420
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1421
                                                        byte & 0x03,       2, 0);
1422 1423
            }
        } else {
1424 1425
            for (n = nb_samples >> (2 - st); n > 0; n--) {
                int byte = bytestream2_get_byteu(&gb);
1426
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1427
                                                        byte >> 6        , 2, 2);
1428
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1429
                                                       (byte >> 4) & 0x03, 2, 2);
1430
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1431
                                                       (byte >> 2) & 0x03, 2, 2);
1432
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1433
                                                        byte & 0x03,       2, 2);
1434 1435 1436
            }
        }
        break;
1437
    case AV_CODEC_ID_ADPCM_SWF:
1438 1439
        adpcm_swf_decode(avctx, buf, buf_size, samples);
        bytestream2_seek(&gb, 0, SEEK_END);
1440
        break;
1441
    case AV_CODEC_ID_ADPCM_YAMAHA:
1442 1443
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v = bytestream2_get_byteu(&gb);
1444 1445
            *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
            *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4  );
1446 1447
        }
        break;
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462
    case AV_CODEC_ID_ADPCM_AICA:
        if (!c->has_status) {
            for (channel = 0; channel < avctx->channels; channel++)
                c->status[channel].step = 0;
            c->has_status = 1;
        }
        for (channel = 0; channel < avctx->channels; channel++) {
            samples = samples_p[channel];
            for (n = nb_samples >> 1; n > 0; n--) {
                int v = bytestream2_get_byteu(&gb);
                *samples++ = adpcm_yamaha_expand_nibble(&c->status[channel], v & 0x0F);
                *samples++ = adpcm_yamaha_expand_nibble(&c->status[channel], v >> 4  );
            }
        }
        break;
Paul B Mahol's avatar
Paul B Mahol committed
1463
    case AV_CODEC_ID_ADPCM_AFC:
Paul B Mahol's avatar
Paul B Mahol committed
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
    {
        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
1477 1478 1479 1480
        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
1481
            samples = samples_p[channel] + m * 16;
Paul B Mahol's avatar
Paul B Mahol committed
1482
            /* Read in every sample for this channel.  */
Paul B Mahol's avatar
Paul B Mahol committed
1483
            for (i = 0; i < samples_per_block; i++) {
Paul B Mahol's avatar
Paul B Mahol committed
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
                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
1512
        }
Paul B Mahol's avatar
Paul B Mahol committed
1513 1514
        bytestream2_seek(&gb, 0, SEEK_END);
        break;
Paul B Mahol's avatar
Paul B Mahol committed
1515
    }
1516
    case AV_CODEC_ID_ADPCM_THP:
1517
    case AV_CODEC_ID_ADPCM_THP_LE:
1518
    {
1519
        int table[14][16];
1520 1521
        int ch;

1522 1523 1524 1525 1526 1527
#define THP_GET16(g) \
    sign_extend( \
        avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE ? \
        bytestream2_get_le16u(&(g)) : \
        bytestream2_get_be16u(&(g)), 16)

1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
        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++)
1538
                    table[i][n] = THP_GET16(tb);
1539
        } else {
1540 1541 1542
            for (i = 0; i < avctx->channels; i++)
                for (n = 0; n < 16; n++)
                    table[i][n] = THP_GET16(gb);
1543

1544 1545 1546 1547 1548 1549 1550 1551 1552
            if (!c->has_status) {
                /* Initialize the previous sample.  */
                for (i = 0; i < avctx->channels; i++) {
                    c->status[i].sample1 = THP_GET16(gb);
                    c->status[i].sample2 = THP_GET16(gb);
                }
                c->has_status = 1;
            } else {
                bytestream2_skip(&gb, avctx->channels * 4);
1553
            }
1554
        }
1555

1556
        for (ch = 0; ch < avctx->channels; ch++) {
1557
            samples = samples_p[ch];
1558 1559

            /* Read in every sample for this channel.  */
1560
            for (i = 0; i < (nb_samples + 13) / 14; i++) {
1561 1562 1563
                int byte = bytestream2_get_byteu(&gb);
                int index = (byte >> 4) & 7;
                unsigned int exp = byte & 0x0F;
1564 1565
                int factor1 = table[ch][index * 2];
                int factor2 = table[ch][index * 2 + 1];
1566 1567

                /* Decode 14 samples.  */
1568
                for (n = 0; n < 14 && (i * 14 + n < nb_samples); n++) {
1569
                    int32_t sampledat;
1570 1571 1572 1573 1574 1575 1576

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

1578 1579
                    sampledat = ((c->status[ch].sample1 * factor1
                                + c->status[ch].sample2 * factor2) >> 11) + (sampledat << exp);
1580
                    *samples = av_clip_int16(sampledat);
1581 1582
                    c->status[ch].sample2 = c->status[ch].sample1;
                    c->status[ch].sample1 = *samples++;
1583 1584 1585 1586
                }
            }
        }
        break;
1587
    }
James Almer's avatar
James Almer committed
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
    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;
                    }

1618
                    prev = av_clip_intp2((prev + 0x20) >> 6, 21);
James Almer's avatar
James Almer committed
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635

                    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;
1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672
    case AV_CODEC_ID_ADPCM_PSX:
        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 filter, shift, flag, byte;

                filter = bytestream2_get_byteu(&gb);
                shift  = filter & 0xf;
                filter = filter >> 4;
                if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table))
                    return AVERROR_INVALIDDATA;
                flag   = bytestream2_get_byteu(&gb);

                /* Decode 28 samples.  */
                for (n = 0; n < 28; n++) {
                    int sample = 0, scale;

                    if (flag < 0x07) {
                        if (n & 1) {
                            scale = sign_extend(byte >> 4, 4);
                        } else {
                            byte  = bytestream2_get_byteu(&gb);
                            scale = sign_extend(byte, 4);
                        }

                        scale  = scale << 12;
                        sample = (int)((scale >> shift) + (c->status[channel].sample1 * xa_adpcm_table[filter][0] + c->status[channel].sample2 * xa_adpcm_table[filter][1]) / 64);
                    }
                    *samples++ = av_clip_int16(sample);
                    c->status[channel].sample2 = c->status[channel].sample1;
                    c->status[channel].sample1 = sample;
                }
            }
        }
        break;
1673

1674 1675 1676
    default:
        return -1;
    }
1677

1678 1679 1680 1681 1682
    if (avpkt->size && bytestream2_tell(&gb) == 0) {
        av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n");
        return AVERROR_INVALIDDATA;
    }

1683
    *got_frame_ptr = 1;
1684

1685 1686 1687 1688 1689
    if (avpkt->size < bytestream2_tell(&gb)) {
        av_log(avctx, AV_LOG_ERROR, "Overread of %d < %d\n", avpkt->size, bytestream2_tell(&gb));
        return avpkt->size;
    }

1690
    return bytestream2_tell(&gb);
1691 1692
}

1693 1694 1695 1696 1697 1698
static void adpcm_flush(AVCodecContext *avctx)
{
    ADPCMDecodeContext *c = avctx->priv_data;
    c->has_status = 0;
}

1699

1700 1701
static const enum AVSampleFormat sample_fmts_s16[]  = { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_NONE };
1702
static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16P,
1703
                                                        AV_SAMPLE_FMT_NONE };
1704 1705 1706
static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_S16P,
                                                        AV_SAMPLE_FMT_NONE };
1707 1708

#define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \
1709 1710
AVCodec ff_ ## name_ ## _decoder = {                        \
    .name           = #name_,                               \
1711
    .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
1712 1713 1714 1715 1716
    .type           = AVMEDIA_TYPE_AUDIO,                   \
    .id             = id_,                                  \
    .priv_data_size = sizeof(ADPCMDecodeContext),           \
    .init           = adpcm_decode_init,                    \
    .decode         = adpcm_decode_frame,                   \
1717
    .flush          = adpcm_flush,                          \
1718
    .capabilities   = AV_CODEC_CAP_DR1,                     \
1719
    .sample_fmts    = sample_fmts_,                         \
1720
}
1721

1722
/* Note: Do not forget to add new entries to the Makefile as well. */
1723
ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM,         sample_fmts_s16p, adpcm_4xm,         "ADPCM 4X Movie");
Paul B Mahol's avatar
Paul B Mahol committed
1724
ADPCM_DECODER(AV_CODEC_ID_ADPCM_AFC,         sample_fmts_s16p, adpcm_afc,         "ADPCM Nintendo Gamecube AFC");
1725
ADPCM_DECODER(AV_CODEC_ID_ADPCM_AICA,        sample_fmts_s16p, adpcm_aica,        "ADPCM Yamaha AICA");
1726
ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT,          sample_fmts_s16,  adpcm_ct,          "ADPCM Creative Technology");
James Almer's avatar
James Almer committed
1727
ADPCM_DECODER(AV_CODEC_ID_ADPCM_DTK,         sample_fmts_s16p, adpcm_dtk,         "ADPCM Nintendo Gamecube DTK");
1728 1729
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");
1730 1731 1732
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");
1733
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS,      sample_fmts_s16p, adpcm_ea_xas,      "ADPCM Electronic Arts XAS");
1734 1735
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");
1736
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DAT4,    sample_fmts_s16,  adpcm_ima_dat4,    "ADPCM IMA Eurocom DAT4");
1737 1738 1739 1740 1741
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");
1742
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_OKI,     sample_fmts_s16,  adpcm_ima_oki,     "ADPCM IMA Dialogic OKI");
1743
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT,      sample_fmts_s16p, adpcm_ima_qt,      "ADPCM IMA QuickTime");
James Almer's avatar
James Almer committed
1744
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_RAD,     sample_fmts_s16,  adpcm_ima_rad,     "ADPCM IMA Radical");
1745
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG,  sample_fmts_s16,  adpcm_ima_smjpeg,  "ADPCM IMA Loki SDL MJPEG");
1746
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV,     sample_fmts_s16p, adpcm_ima_wav,     "ADPCM IMA WAV");
1747
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS,      sample_fmts_both, adpcm_ima_ws,      "ADPCM IMA Westwood");
1748
ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS,          sample_fmts_s16,  adpcm_ms,          "ADPCM Microsoft");
1749
ADPCM_DECODER(AV_CODEC_ID_ADPCM_MTAF,        sample_fmts_s16p, adpcm_mtaf,        "ADPCM MTAF");
1750
ADPCM_DECODER(AV_CODEC_ID_ADPCM_PSX,         sample_fmts_s16p, adpcm_psx,         "ADPCM Playstation");
1751 1752 1753 1754
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");
1755 1756
ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP_LE,      sample_fmts_s16p, adpcm_thp_le,      "ADPCM Nintendo THP (little-endian)");
ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP,         sample_fmts_s16p, adpcm_thp,         "ADPCM Nintendo THP");
1757
ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA,          sample_fmts_s16p, adpcm_xa,          "ADPCM CDROM XA");
1758
ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA,      sample_fmts_s16,  adpcm_yamaha,      "ADPCM Yamaha");