adpcm.c 79.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
 * 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)
15
 * Argonaut Games ADPCM decoder by Zane van Iperen (zane@zanevaniperen.com)
16
 * Simon & Schuster Interactive ADPCM decoder by Zane van Iperen (zane@zanevaniperen.com)
17
 * Ubisoft ADPCM decoder by Zane van Iperen (zane@zanevaniperen.com)
18
 * High Voltage Software ALP decoder by Zane van Iperen (zane@zanevaniperen.com)
19
 *
20 21 22
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
23 24
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
25
 * version 2.1 of the License, or (at your option) any later version.
26
 *
27
 * FFmpeg is distributed in the hope that it will be useful,
28 29 30 31 32
 * 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
33
 * License along with FFmpeg; if not, write to the Free Software
34
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
35 36
 */
#include "avcodec.h"
37
#include "get_bits.h"
38
#include "bytestream.h"
39 40
#include "adpcm.h"
#include "adpcm_data.h"
41
#include "internal.h"
42

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

63
/* These are for CD-ROM XA ADPCM */
64
static const int8_t xa_adpcm_table[5][2] = {
65 66 67 68 69
    {   0,   0 },
    {  60,   0 },
    { 115, -52 },
    {  98, -55 },
    { 122, -60 }
70 71
};

72
static const int16_t ea_adpcm_table[] = {
73 74 75 76 77
    0,  240,  460,  392,
    0,    0, -208, -220,
    0,    1,    3,    4,
    7,    8,   10,   11,
    0,   -1,   -3,   -4
78 79
};

80
// padded to zero where table size is less then 16
81
static const int8_t swf_index_tables[4][16] = {
82 83 84 85 86 87
    /*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 }
};

88 89 90 91
static const int8_t zork_index_table[8] = {
    -1, -1, -1, 1, 4, 7, 10, 12,
};

92 93 94 95 96
static const int8_t mtf_index_table[16] = {
     8,  6,  4,  2, -1, -1, -1, -1,
    -1, -1, -1, -1,  2,  4,  6,  8,
};

97 98
/* end of tables */

99
typedef struct ADPCMDecodeContext {
100
    ADPCMChannelStatus status[14];
101
    int vqa_version;                /**< VQA version. Used for ADPCM_IMA_WS */
102
    int has_status;
103
} ADPCMDecodeContext;
104

105
static av_cold int adpcm_decode_init(AVCodecContext * avctx)
106
{
107
    ADPCMDecodeContext *c = avctx->priv_data;
108
    unsigned int min_channels = 1;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
109
    unsigned int max_channels = 2;
110

111
    switch(avctx->codec->id) {
James Almer's avatar
James Almer committed
112
    case AV_CODEC_ID_ADPCM_DTK:
113
    case AV_CODEC_ID_ADPCM_EA:
114 115
        min_channels = 2;
        break;
116
    case AV_CODEC_ID_ADPCM_AFC:
117 118 119 120
    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:
121
    case AV_CODEC_ID_ADPCM_MS:
122 123
        max_channels = 6;
        break;
124 125 126
    case AV_CODEC_ID_ADPCM_MTAF:
        min_channels = 2;
        max_channels = 8;
127 128 129 130
        if (avctx->channels & 1) {
            avpriv_request_sample(avctx, "channel count %d\n", avctx->channels);
            return AVERROR_PATCHWELCOME;
        }
131
        break;
132 133 134
    case AV_CODEC_ID_ADPCM_PSX:
        max_channels = 8;
        break;
135
    case AV_CODEC_ID_ADPCM_IMA_DAT4:
136
    case AV_CODEC_ID_ADPCM_THP:
137
    case AV_CODEC_ID_ADPCM_THP_LE:
138
        max_channels = 14;
139 140
        break;
    }
141
    if (avctx->channels < min_channels || avctx->channels > max_channels) {
142 143
        av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
        return AVERROR(EINVAL);
144 145
    }

146
    switch(avctx->codec->id) {
147
    case AV_CODEC_ID_ADPCM_CT:
148 149
        c->status[0].step = c->status[1].step = 511;
        break;
150
    case AV_CODEC_ID_ADPCM_IMA_WAV:
151 152
        if (avctx->bits_per_coded_sample < 2 || avctx->bits_per_coded_sample > 5)
            return AVERROR_INVALIDDATA;
153
        break;
154
    case AV_CODEC_ID_ADPCM_IMA_APC:
155
        if (avctx->extradata && avctx->extradata_size >= 8) {
156 157
            c->status[0].predictor = av_clip_intp2(AV_RL32(avctx->extradata    ), 18);
            c->status[1].predictor = av_clip_intp2(AV_RL32(avctx->extradata + 4), 18);
Anssi Hannula's avatar
Anssi Hannula committed
158 159
        }
        break;
160 161 162
    case AV_CODEC_ID_ADPCM_IMA_APM:
        if (avctx->extradata && avctx->extradata_size >= 16) {
            c->status[0].predictor  = AV_RL32(avctx->extradata +  0);
163
            c->status[0].step_index = av_clip(AV_RL32(avctx->extradata +  4), 0, 88);
164
            c->status[1].predictor  = AV_RL32(avctx->extradata +  8);
165
            c->status[1].step_index = av_clip(AV_RL32(avctx->extradata + 12), 0, 88);
166 167
        }
        break;
168
    case AV_CODEC_ID_ADPCM_IMA_WS:
169
        if (avctx->extradata && avctx->extradata_size >= 2)
170 171
            c->vqa_version = AV_RL16(avctx->extradata);
        break;
172 173 174 175
    case AV_CODEC_ID_ADPCM_ARGO:
        if (avctx->bits_per_coded_sample != 4)
            return AVERROR_INVALIDDATA;
        break;
176 177 178 179
    case AV_CODEC_ID_ADPCM_ZORK:
        if (avctx->bits_per_coded_sample != 8)
            return AVERROR_INVALIDDATA;
        break;
180 181 182
    default:
        break;
    }
183

184 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 213
    switch (avctx->codec->id) {
    case AV_CODEC_ID_ADPCM_AICA:
    case AV_CODEC_ID_ADPCM_IMA_DAT4:
    case AV_CODEC_ID_ADPCM_IMA_QT:
    case AV_CODEC_ID_ADPCM_IMA_WAV:
    case AV_CODEC_ID_ADPCM_4XM:
    case AV_CODEC_ID_ADPCM_XA:
    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:
    case AV_CODEC_ID_ADPCM_THP:
    case AV_CODEC_ID_ADPCM_THP_LE:
    case AV_CODEC_ID_ADPCM_AFC:
    case AV_CODEC_ID_ADPCM_DTK:
    case AV_CODEC_ID_ADPCM_PSX:
    case AV_CODEC_ID_ADPCM_MTAF:
    case AV_CODEC_ID_ADPCM_ARGO:
        avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
        break;
    case AV_CODEC_ID_ADPCM_IMA_WS:
        avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
                                                  AV_SAMPLE_FMT_S16;
        break;
    case AV_CODEC_ID_ADPCM_MS:
        avctx->sample_fmt = avctx->channels > 2 ? AV_SAMPLE_FMT_S16P :
                                                  AV_SAMPLE_FMT_S16;
        break;
    default:
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
214
    }
215

216 217 218
    return 0;
}

219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
static inline int16_t adpcm_agm_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
{
    int delta, pred, step, add;

    pred = c->predictor;
    delta = nibble & 7;
    step = c->step;
    add = (delta * 2 + 1) * step;
    if (add < 0)
        add = add + 7;

    if ((nibble & 8) == 0)
        pred = av_clip(pred + (add >> 3), -32767, 32767);
    else
        pred = av_clip(pred - (add >> 3), -32767, 32767);

    switch (delta) {
    case 7:
        step *= 0x99;
        break;
    case 6:
        c->step = av_clip(c->step * 2, 127, 24576);
        c->predictor = pred;
        return pred;
    case 5:
        step *= 0x66;
        break;
    case 4:
        step *= 0x4d;
        break;
    default:
        step *= 0x39;
        break;
    }

    if (step < 0)
        step += 0x3f;

    c->step = step >> 6;
    c->step = av_clip(c->step, 127, 24576);
    c->predictor = pred;
    return pred;
}

263
static inline int16_t adpcm_ima_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
264 265 266 267 268
{
    int step_index;
    int predictor;
    int sign, delta, diff, step;

269 270
    step = ff_adpcm_step_table[c->step_index];
    step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
271
    step_index = av_clip(step_index, 0, 88);
272 273 274

    sign = nibble & 8;
    delta = nibble & 7;
275 276 277
    /* 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
278
    diff = ((2 * delta + 1) * step) >> shift;
Michael Niedermayer's avatar
Michael Niedermayer committed
279 280 281 282
    predictor = c->predictor;
    if (sign) predictor -= diff;
    else predictor += diff;

283
    c->predictor = av_clip_int16(predictor);
Michael Niedermayer's avatar
Michael Niedermayer committed
284 285
    c->step_index = step_index;

286
    return (int16_t)c->predictor;
Michael Niedermayer's avatar
Michael Niedermayer committed
287 288
}

289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
static inline int16_t adpcm_ima_alp_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
{
    int step_index;
    int predictor;
    int sign, delta, diff, step;

    step = ff_adpcm_step_table[c->step_index];
    step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
    step_index = av_clip(step_index, 0, 88);

    sign = nibble & 8;
    delta = nibble & 7;
    diff = (delta * 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;
}

312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
static inline int16_t adpcm_ima_mtf_expand_nibble(ADPCMChannelStatus *c, int nibble)
{
    int step_index, step, delta, predictor;

    step = ff_adpcm_step_table[c->step_index];

    delta = step * (2 * nibble - 15);
    predictor = c->predictor + delta;

    step_index = c->step_index + mtf_index_table[(unsigned)nibble];
    c->predictor = av_clip_int16(predictor >> 4);
    c->step_index = av_clip(step_index, 0, 88);

    return (int16_t)c->predictor;
}

328 329 330 331 332 333 334 335 336 337 338
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);
339
    delta = av_mod_uintp2(nibble, shift);
340 341 342 343 344 345 346 347 348 349 350
    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;
}

351
static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble)
352 353 354 355 356
{
    int step_index;
    int predictor;
    int diff, step;

357 358
    step = ff_adpcm_step_table[c->step_index];
    step_index = c->step_index + ff_adpcm_index_table[nibble];
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
    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;
}

377
static inline int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
378 379 380
{
    int predictor;

381
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
382
    predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
383 384

    c->sample2 = c->sample1;
385
    c->sample1 = av_clip_int16(predictor);
386
    c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
387
    if (c->idelta < 16) c->idelta = 16;
388 389 390 391
    if (c->idelta > INT_MAX/768) {
        av_log(NULL, AV_LOG_WARNING, "idelta overflow\n");
        c->idelta = INT_MAX/768;
    }
392

393
    return c->sample1;
394 395
}

396
static inline int16_t adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)
397 398 399 400 401 402 403 404 405 406 407 408 409 410
{
    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;

411
    c->predictor = av_clip_intp2(predictor, 11);
412 413
    c->step_index = step_index;

414
    return c->predictor * 16;
415 416
}

417
static inline int16_t adpcm_ct_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
418 419 420 421 422 423 424 425 426 427 428
{
    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 */
429 430
    c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
    c->predictor = av_clip_int16(c->predictor);
431
    /* calculate new step and clamp it to range 511..32767 */
432
    new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
433
    c->step = av_clip(new_step, 511, 32767);
434

435
    return (int16_t)c->predictor;
436 437
}

438
static inline int16_t adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int size, int shift)
439 440 441 442 443 444 445 446
{
    int sign, delta, diff;

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

    /* clamp result */
447
    c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
448 449 450 451 452 453 454

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

455
    return (int16_t) c->predictor;
456 457
}

458
static inline int16_t adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
459 460 461 462 463 464
{
    if(!c->step) {
        c->predictor = 0;
        c->step = 127;
    }

465
    c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
466
    c->predictor = av_clip_int16(c->predictor);
467
    c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
468
    c->step = av_clip(c->step, 127, 24576);
469 470 471
    return c->predictor;
}

472 473 474 475 476 477 478 479 480
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;
}

481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
static inline int16_t adpcm_zork_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
{
    int16_t index = c->step_index;
    uint32_t lookup_sample = ff_adpcm_step_table[index];
    int32_t sample = 0;

    if (nibble & 0x40)
        sample += lookup_sample;
    if (nibble & 0x20)
        sample += lookup_sample >> 1;
    if (nibble & 0x10)
        sample += lookup_sample >> 2;
    if (nibble & 0x08)
        sample += lookup_sample >> 3;
    if (nibble & 0x04)
        sample += lookup_sample >> 4;
    if (nibble & 0x02)
        sample += lookup_sample >> 5;
    if (nibble & 0x01)
        sample += lookup_sample >> 6;
    if (nibble & 0x80)
        sample = -sample;

    sample += c->predictor;
    sample = av_clip_int16(sample);

    index += zork_index_table[(nibble >> 4) & 7];
    index = av_clip(index, 0, 88);

    c->predictor = sample;
    c->step_index = index;

    return sample;
}

516 517 518
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)
519 520 521 522 523 524
{
    int i, j;
    int shift,filter,f0,f1;
    int s_1,s_2;
    int d,s,t;

525 526 527 528 529
    out0 += sample_offset;
    if (channels == 1)
        out1 = out0 + 28;
    else
        out1 += sample_offset;
530

531
    for(i=0;i<4;i++) {
532 533
        shift  = 12 - (in[4+i*2] & 15);
        filter = in[4+i*2] >> 4;
534
        if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
535
            avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
536 537
            filter=0;
        }
538 539 540 541 542 543 544 545 546
        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];

547
            t = sign_extend(d, 4);
548
            s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
549
            s_2 = s_1;
550
            s_1 = av_clip_int16(s);
551
            out0[j] = s_1;
552 553
        }

554
        if (channels == 2) {
555 556 557 558 559 560 561 562
            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;
563
        if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
564
            avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
565 566
            filter=0;
        }
567 568 569 570 571 572 573

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

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

574
            t = sign_extend(d >> 4, 4);
575
            s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
576
            s_2 = s_1;
577
            s_1 = av_clip_int16(s);
578
            out1[j] = s_1;
579 580
        }

581
        if (channels == 2) {
582 583 584 585 586 587
            right->sample1 = s_1;
            right->sample2 = s_2;
        } else {
            left->sample1 = s_1;
            left->sample2 = s_2;
        }
588 589 590

        out0 += 28 * (3 - channels);
        out1 += 28 * (3 - channels);
591
    }
592 593

    return 0;
594 595
}

596 597 598 599
static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
{
    ADPCMDecodeContext *c = avctx->priv_data;
    GetBitContext gb;
600
    const int8_t *table;
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
    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];
626
                int vpdiff = 0; // vpdiff = (delta+0.5)*step/4
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
                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;
            }
        }
    }
}

653
static inline int16_t adpcm_argo_expand_nibble(ADPCMChannelStatus *cs, int nibble, int control, int shift)
654
{
655 656 657 658 659 660 661 662 663 664 665 666 667
    int sample = nibble * (1 << shift);

    if (control & 0x04)
        sample += (8 * cs->sample1) - (4 * cs->sample2);
    else
        sample += 4 * cs->sample1;

    sample = av_clip_int16(sample >> 2);

    cs->sample2 = cs->sample1;
    cs->sample1 = sample;

    return sample;
668 669
}

670
/**
671
 * Get the number of samples (per channel) that will be decoded from the packet.
672 673 674 675 676 677
 * 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.
678 679
 * @param[out] approx_nb_samples set to non-zero if the number of samples
 *                               returned is an approximation.
680
 */
681
static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
682
                          int buf_size, int *coded_samples, int *approx_nb_samples)
683 684 685 686 687 688 689 690
{
    ADPCMDecodeContext *s = avctx->priv_data;
    int nb_samples        = 0;
    int ch                = avctx->channels;
    int has_coded_samples = 0;
    int header_size;

    *coded_samples = 0;
691
    *approx_nb_samples = 0;
692

693 694 695
    if(ch <= 0)
        return 0;

696 697
    switch (avctx->codec->id) {
    /* constant, only check buf_size */
698
    case AV_CODEC_ID_ADPCM_EA_XAS:
699 700 701 702
        if (buf_size < 76 * ch)
            return 0;
        nb_samples = 128;
        break;
703
    case AV_CODEC_ID_ADPCM_IMA_QT:
704 705 706 707
        if (buf_size < 34 * ch)
            return 0;
        nb_samples = 64;
        break;
708 709 710 711 712
    case AV_CODEC_ID_ADPCM_ARGO:
        if (buf_size < 17 * ch)
            return 0;
        nb_samples = 32;
        break;
713
    /* simple 4-bit adpcm */
714 715 716
    case AV_CODEC_ID_ADPCM_CT:
    case AV_CODEC_ID_ADPCM_IMA_APC:
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
717
    case AV_CODEC_ID_ADPCM_IMA_OKI:
718 719
    case AV_CODEC_ID_ADPCM_IMA_WS:
    case AV_CODEC_ID_ADPCM_YAMAHA:
720
    case AV_CODEC_ID_ADPCM_AICA:
721
    case AV_CODEC_ID_ADPCM_IMA_SSI:
722
    case AV_CODEC_ID_ADPCM_IMA_APM:
723
    case AV_CODEC_ID_ADPCM_IMA_ALP:
724
    case AV_CODEC_ID_ADPCM_IMA_MTF:
725 726 727 728 729 730 731 732 733
        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) {
734
        case AV_CODEC_ID_ADPCM_4XM:
735
        case AV_CODEC_ID_ADPCM_AGM:
736
        case AV_CODEC_ID_ADPCM_IMA_DAT4:
737 738
        case AV_CODEC_ID_ADPCM_IMA_ISS:     header_size = 4 * ch;      break;
        case AV_CODEC_ID_ADPCM_IMA_AMV:     header_size = 8;           break;
739
        case AV_CODEC_ID_ADPCM_IMA_SMJPEG:  header_size = 4 * ch;      break;
740 741 742 743 744 745
    }
    if (header_size > 0)
        return (buf_size - header_size) * 2 / ch;

    /* more complex formats */
    switch (avctx->codec->id) {
746
    case AV_CODEC_ID_ADPCM_EA:
747
        has_coded_samples = 1;
748
        *coded_samples  = bytestream2_get_le32(gb);
749 750 751
        *coded_samples -= *coded_samples % 28;
        nb_samples      = (buf_size - 12) / 30 * 28;
        break;
752
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
753
        has_coded_samples = 1;
754
        *coded_samples = bytestream2_get_le32(gb);
755 756
        nb_samples     = (buf_size - (4 + 8 * ch)) * 2 / ch;
        break;
757
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
758
        nb_samples = (buf_size - ch) / ch * 2;
759
        break;
760 761 762
    case AV_CODEC_ID_ADPCM_EA_R1:
    case AV_CODEC_ID_ADPCM_EA_R2:
    case AV_CODEC_ID_ADPCM_EA_R3:
763 764 765 766
        /* 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) {
767
        case AV_CODEC_ID_ADPCM_EA_R1:
768
            header_size    = 4 + 9 * ch;
769
            *coded_samples = bytestream2_get_le32(gb);
770
            break;
771
        case AV_CODEC_ID_ADPCM_EA_R2:
772
            header_size    = 4 + 5 * ch;
773
            *coded_samples = bytestream2_get_le32(gb);
774
            break;
775
        case AV_CODEC_ID_ADPCM_EA_R3:
776
            header_size    = 4 + 5 * ch;
777
            *coded_samples = bytestream2_get_be32(gb);
778 779 780 781 782
            break;
        }
        *coded_samples -= *coded_samples % 28;
        nb_samples      = (buf_size - header_size) * 2 / ch;
        nb_samples     -= nb_samples % 28;
783
        *approx_nb_samples = 1;
784
        break;
785
    case AV_CODEC_ID_ADPCM_IMA_DK3:
786 787
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
788
        nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
789
        break;
790
    case AV_CODEC_ID_ADPCM_IMA_DK4:
791 792
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
793 794
        if (buf_size < 4 * ch)
            return AVERROR_INVALIDDATA;
795 796
        nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
        break;
James Almer's avatar
James Almer committed
797 798 799 800 801
    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;
802
    case AV_CODEC_ID_ADPCM_IMA_WAV:
803 804 805
    {
        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];
806 807
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
808 809
        if (buf_size < 4 * ch)
            return AVERROR_INVALIDDATA;
810
        nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;
811
        break;
812
    }
813
    case AV_CODEC_ID_ADPCM_MS:
814 815
        if (avctx->block_align > 0)
            buf_size = FFMIN(buf_size, avctx->block_align);
816
        nb_samples = (buf_size - 6 * ch) * 2 / ch;
817
        break;
818 819 820 821 822
    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;
823 824 825
    case AV_CODEC_ID_ADPCM_SBPRO_2:
    case AV_CODEC_ID_ADPCM_SBPRO_3:
    case AV_CODEC_ID_ADPCM_SBPRO_4:
826 827 828
    {
        int samples_per_byte;
        switch (avctx->codec->id) {
829 830 831
        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;
832 833
        }
        if (!s->status[0].step_index) {
834 835
            if (buf_size < ch)
                return AVERROR_INVALIDDATA;
836 837 838 839 840 841
            nb_samples++;
            buf_size -= ch;
        }
        nb_samples += buf_size * samples_per_byte / ch;
        break;
    }
842
    case AV_CODEC_ID_ADPCM_SWF:
843 844
    {
        int buf_bits       = buf_size * 8 - 2;
845
        int nbits          = (bytestream2_get_byte(gb) >> 6) + 2;
846 847 848 849 850 851 852 853 854
        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;
    }
855
    case AV_CODEC_ID_ADPCM_THP:
856
    case AV_CODEC_ID_ADPCM_THP_LE:
857
        if (avctx->extradata) {
858
            nb_samples = buf_size * 14 / (8 * ch);
859 860
            break;
        }
861
        has_coded_samples = 1;
862
        bytestream2_skip(gb, 4); // channel size
863 864 865
        *coded_samples  = (avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE) ?
                          bytestream2_get_le32(gb) :
                          bytestream2_get_be32(gb);
866 867 868
        buf_size       -= 8 + 36 * ch;
        buf_size       /= ch;
        nb_samples      = buf_size / 8 * 14;
869
        if (buf_size % 8 > 1)
870
            nb_samples     += (buf_size % 8 - 1) * 2;
871
        *approx_nb_samples = 1;
872
        break;
Paul B Mahol's avatar
Paul B Mahol committed
873 874 875
    case AV_CODEC_ID_ADPCM_AFC:
        nb_samples = buf_size / (9 * ch) * 16;
        break;
876
    case AV_CODEC_ID_ADPCM_XA:
877 878
        nb_samples = (buf_size / 128) * 224 / ch;
        break;
James Almer's avatar
James Almer committed
879
    case AV_CODEC_ID_ADPCM_DTK:
880
    case AV_CODEC_ID_ADPCM_PSX:
James Almer's avatar
James Almer committed
881 882
        nb_samples = buf_size / (16 * ch) * 28;
        break;
883 884 885
    case AV_CODEC_ID_ADPCM_ZORK:
        nb_samples = buf_size / ch;
        break;
886 887 888 889 890 891 892 893
    }

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

    return nb_samples;
}
894

895 896
static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame_ptr, AVPacket *avpkt)
897
{
898
    AVFrame *frame     = data;
899 900
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
901
    ADPCMDecodeContext *c = avctx->priv_data;
902
    ADPCMChannelStatus *cs;
Michael Niedermayer's avatar
Michael Niedermayer committed
903
    int n, m, channel, i;
904
    int16_t *samples;
905
    int16_t **samples_p;
906
    int st; /* stereo */
907
    int count1, count2;
908
    int nb_samples, coded_samples, approx_nb_samples, ret;
909
    GetByteContext gb;
910

911
    bytestream2_init(&gb, buf, buf_size);
912
    nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);
913 914 915 916
    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
917

918
    /* get output buffer */
919
    frame->nb_samples = nb_samples;
920
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
921
        return ret;
922
    samples = (int16_t *)frame->data[0];
923
    samples_p = (int16_t **)frame->extended_data;
924

925 926 927
    /* use coded_samples when applicable */
    /* it is always <= nb_samples, so the output buffer will be large enough */
    if (coded_samples) {
928
        if (!approx_nb_samples && coded_samples != nb_samples)
929
            av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
930
        frame->nb_samples = nb_samples = coded_samples;
931
    }
932

933
    st = avctx->channels == 2 ? 1 : 0;
934 935

    switch(avctx->codec->id) {
936
    case AV_CODEC_ID_ADPCM_IMA_QT:
937 938
        /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
           Channel data is interleaved per-chunk. */
939
        for (channel = 0; channel < avctx->channels; channel++) {
940
            int predictor;
941
            int step_index;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
942 943
            cs = &(c->status[channel]);
            /* (pppppp) (piiiiiii) */
944

Baptiste Coudurier's avatar
Baptiste Coudurier committed
945
            /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
946
            predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
947
            step_index = predictor & 0x7F;
948
            predictor &= ~0x7F;
949 950

            if (cs->step_index == step_index) {
951
                int diff = predictor - cs->predictor;
952 953 954 955 956 957 958 959 960
                if (diff < 0)
                    diff = - diff;
                if (diff > 0x7f)
                    goto update;
            } else {
            update:
                cs->step_index = step_index;
                cs->predictor = predictor;
            }
961

962 963 964 965
            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
966
            }
967

968
            samples = samples_p[channel];
969

970
            for (m = 0; m < 64; m += 2) {
971
                int byte = bytestream2_get_byteu(&gb);
972 973
                samples[m    ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F);
                samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4  );
Baptiste Coudurier's avatar
Baptiste Coudurier committed
974
            }
975 976
        }
        break;
977
    case AV_CODEC_ID_ADPCM_IMA_WAV:
Michael Niedermayer's avatar
Michael Niedermayer committed
978 979
        for(i=0; i<avctx->channels; i++){
            cs = &(c->status[i]);
980
            cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
981

982 983 984 985 986
            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;
987
            }
988 989
        }

990 991
        if (avctx->bits_per_coded_sample != 4) {
            int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
992
            int block_size = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
993
            uint8_t temp[20 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
994 995 996 997
            GetBitContext g;

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

1000 1001
                    cs = &c->status[i];
                    samples = &samples_p[i][1 + n * samples_per_block];
1002 1003 1004 1005 1006 1007 1008
                    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;
1009 1010 1011 1012 1013 1014 1015 1016
                    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 {
1017
        for (n = 0; n < (nb_samples - 1) / 8; n++) {
1018 1019
            for (i = 0; i < avctx->channels; i++) {
                cs = &c->status[i];
1020 1021
                samples = &samples_p[i][1 + n * 8];
                for (m = 0; m < 8; m += 2) {
1022
                    int v = bytestream2_get_byteu(&gb);
1023 1024
                    samples[m    ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
                    samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
1025
                }
1026 1027
            }
        }
1028
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1029
        break;
1030
    case AV_CODEC_ID_ADPCM_4XM:
1031
        for (i = 0; i < avctx->channels; i++)
1032
            c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
Michael Niedermayer's avatar
Michael Niedermayer committed
1033

1034
        for (i = 0; i < avctx->channels; i++) {
1035 1036 1037 1038 1039 1040
            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;
            }
1041
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1042

1043
        for (i = 0; i < avctx->channels; i++) {
1044
            samples = (int16_t *)frame->data[i];
1045
            cs = &c->status[i];
1046 1047
            for (n = nb_samples >> 1; n > 0; n--) {
                int v = bytestream2_get_byteu(&gb);
1048 1049
                *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
                *samples++ = adpcm_ima_expand_nibble(cs, v >> 4  , 4);
1050 1051
            }
        }
1052
        break;
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
    case AV_CODEC_ID_ADPCM_AGM:
        for (i = 0; i < avctx->channels; i++)
            c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
        for (i = 0; i < avctx->channels; i++)
            c->status[i].step = sign_extend(bytestream2_get_le16u(&gb), 16);

        for (n = 0; n < nb_samples >> (1 - st); n++) {
            int v = bytestream2_get_byteu(&gb);
            *samples++ = adpcm_agm_expand_nibble(&c->status[0], v & 0xF);
            *samples++ = adpcm_agm_expand_nibble(&c->status[st], v >> 4 );
        }
        break;
1065
    case AV_CODEC_ID_ADPCM_MS:
1066 1067 1068
    {
        int block_predictor;

1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
        if (avctx->channels > 2) {
            for (channel = 0; channel < avctx->channels; channel++) {
                samples = samples_p[channel];
                block_predictor = bytestream2_get_byteu(&gb);
                if (block_predictor > 6) {
                    av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[%d] = %d\n",
                           channel, block_predictor);
                    return AVERROR_INVALIDDATA;
                }
                c->status[channel].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
                c->status[channel].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
                c->status[channel].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
                c->status[channel].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
                c->status[channel].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
                *samples++ = c->status[channel].sample2;
                *samples++ = c->status[channel].sample1;
                for(n = (nb_samples - 2) >> 1; n > 0; n--) {
                    int byte = bytestream2_get_byteu(&gb);
                    *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte >> 4  );
                    *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte & 0x0F);
                }
            }
        } else {
1092 1093
            block_predictor = bytestream2_get_byteu(&gb);
            if (block_predictor > 6) {
1094
                av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
1095 1096 1097
                       block_predictor);
                return AVERROR_INVALIDDATA;
            }
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
            c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
            c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
            if (st) {
                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;
                }
                c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
                c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
            }
            c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
            if (st){
                c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
            }
1114

1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
            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);

            *samples++ = c->status[0].sample2;
            if (st) *samples++ = c->status[1].sample2;
            *samples++ = c->status[0].sample1;
            if (st) *samples++ = c->status[1].sample1;
            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);
            }
1129
        }
1130
        break;
1131
    }
1132 1133 1134
    case AV_CODEC_ID_ADPCM_MTAF:
        for (channel = 0; channel < avctx->channels; channel+=2) {
            bytestream2_skipu(&gb, 4);
1135 1136
            c->status[channel    ].step      = bytestream2_get_le16u(&gb) & 0x1f;
            c->status[channel + 1].step      = bytestream2_get_le16u(&gb) & 0x1f;
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
            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;
1153
    case AV_CODEC_ID_ADPCM_IMA_DK4:
1154 1155
        for (channel = 0; channel < avctx->channels; channel++) {
            cs = &c->status[channel];
1156 1157 1158 1159 1160 1161 1162
            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;
            }
1163
        }
1164
        for (n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
1165
            int v = bytestream2_get_byteu(&gb);
1166 1167
            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4  , 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1168 1169
        }
        break;
1170
    case AV_CODEC_ID_ADPCM_IMA_DK3:
1171
    {
1172 1173
        int last_byte = 0;
        int nibble;
1174 1175
        int decode_top_nibble_next = 0;
        int diff_channel;
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
        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;
        }
1188 1189 1190
        /* sign extend the predictors */
        diff_channel = c->status[1].predictor;

1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
        /* 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) {
1203 1204 1205 1206 1207 1208

            /* 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
1209
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1210 1211 1212

            /* process the diff channel predictor */
            DK3_GET_NEXT_NIBBLE();
Michael Niedermayer's avatar
Michael Niedermayer committed
1213
            adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
1214 1215 1216 1217 1218 1219 1220 1221

            /* 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
1222
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1223 1224 1225 1226 1227 1228

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

        if ((bytestream2_tell(&gb) & 1))
            bytestream2_skip(&gb, 1);
1232
        break;
1233
    }
1234
    case AV_CODEC_ID_ADPCM_IMA_ISS:
1235 1236
        for (channel = 0; channel < avctx->channels; channel++) {
            cs = &c->status[channel];
1237 1238 1239 1240 1241 1242 1243
            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;
            }
1244 1245
        }

1246 1247 1248
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v1, v2;
            int v = bytestream2_get_byteu(&gb);
1249
            /* nibbles are swapped for mono */
1250
            if (st) {
1251 1252
                v1 = v >> 4;
                v2 = v & 0x0F;
1253
            } else {
1254 1255
                v2 = v >> 4;
                v1 = v & 0x0F;
1256
            }
1257 1258
            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
1259 1260
        }
        break;
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
    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;
1273
    case AV_CODEC_ID_ADPCM_IMA_APC:
1274
        for (n = nb_samples >> (1 - st); n > 0; n--) {
1275
            int v = bytestream2_get_byteu(&gb);
1276 1277
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  v >> 4  , 3);
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1278 1279
        }
        break;
1280
    case AV_CODEC_ID_ADPCM_IMA_SSI:
1281
        for (n = nb_samples >> (1 - st); n > 0; n--) {
1282
            int v = bytestream2_get_byteu(&gb);
1283 1284
            *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0],  v >> 4  );
            *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0x0F);
1285 1286
        }
        break;
1287 1288 1289 1290
    case AV_CODEC_ID_ADPCM_IMA_APM:
        for (n = nb_samples / 2; n > 0; n--) {
            for (channel = 0; channel < avctx->channels; channel++) {
                int v = bytestream2_get_byteu(&gb);
1291 1292
                *samples++  = adpcm_ima_qt_expand_nibble(&c->status[channel], v >> 4  );
                samples[st] = adpcm_ima_qt_expand_nibble(&c->status[channel], v & 0x0F);
1293 1294 1295 1296
            }
            samples += avctx->channels;
        }
        break;
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
    case AV_CODEC_ID_ADPCM_IMA_ALP:
        for (n = nb_samples / 2; n > 0; n--) {
            for (channel = 0; channel < avctx->channels; channel++) {
                int v = bytestream2_get_byteu(&gb);
                *samples++  = adpcm_ima_alp_expand_nibble(&c->status[channel], v >> 4  , 2);
                samples[st] = adpcm_ima_alp_expand_nibble(&c->status[channel], v & 0x0F, 2);
            }
            samples += avctx->channels;
        }
        break;
1307
    case AV_CODEC_ID_ADPCM_IMA_OKI:
1308
        for (n = nb_samples >> (1 - st); n > 0; n--) {
1309 1310 1311 1312 1313
            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
1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338
    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;
1339
    case AV_CODEC_ID_ADPCM_IMA_WS:
1340 1341
        if (c->vqa_version == 3) {
            for (channel = 0; channel < avctx->channels; channel++) {
1342
                int16_t *smp = samples_p[channel];
1343

1344 1345
                for (n = nb_samples / 2; n > 0; n--) {
                    int v = bytestream2_get_byteu(&gb);
1346 1347
                    *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4  , 3);
                    *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1348
                }
1349
            }
1350
        } else {
1351
            for (n = nb_samples / 2; n > 0; n--) {
1352 1353 1354 1355 1356 1357
                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;
1358 1359
            }
        }
1360
        bytestream2_seek(&gb, 0, SEEK_END);
1361
        break;
1362
    case AV_CODEC_ID_ADPCM_XA:
1363 1364 1365 1366 1367
    {
        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;
1368
        int bytes_remaining;
1369
        while (bytestream2_get_bytes_left(&gb) >= 128) {
1370 1371 1372
            if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
                                 &c->status[0], &c->status[1],
                                 avctx->channels, sample_offset)) < 0)
1373
                return ret;
1374
            bytestream2_skipu(&gb, 128);
1375
            sample_offset += samples_per_block;
1376
        }
1377 1378 1379 1380 1381 1382
        /* Less than a full block of data left, e.g. when reading from
         * 2324 byte per sector XA; the remainder is padding */
        bytes_remaining = bytestream2_get_bytes_left(&gb);
        if (bytes_remaining > 0) {
            bytestream2_skip(&gb, bytes_remaining);
        }
1383
        break;
1384
    }
1385
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
1386 1387 1388 1389 1390 1391 1392 1393
        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;
            }
        }
1394
        for (i=0; i<=st; i++) {
1395
            c->status[i].predictor  = bytestream2_get_le32u(&gb);
1396
            if (FFABS((int64_t)c->status[i].predictor) > (1<<16))
1397 1398
                return AVERROR_INVALIDDATA;
        }
Peter Ross's avatar
Peter Ross committed
1399

1400 1401 1402 1403
        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
1404 1405
        }
        break;
1406
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
1407 1408 1409 1410
        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
1411 1412
        }
        break;
1413
    case AV_CODEC_ID_ADPCM_EA:
1414
    {
1415 1416 1417 1418 1419
        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;
1420

1421 1422
        /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
           each coding 28 stereo samples. */
1423

Michael Niedermayer's avatar
Michael Niedermayer committed
1424 1425 1426
        if(avctx->channels != 2)
            return AVERROR_INVALIDDATA;

1427 1428 1429 1430
        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);
1431

1432
        for (count1 = 0; count1 < nb_samples / 28; count1++) {
1433 1434 1435 1436 1437
            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];
1438

1439 1440 1441
            byte = bytestream2_get_byteu(&gb);
            shift_left  = 20 - (byte >> 4);
            shift_right = 20 - (byte & 0x0F);
1442 1443

            for (count2 = 0; count2 < 28; count2++) {
1444
                byte = bytestream2_get_byteu(&gb);
1445 1446
                next_left_sample  = sign_extend(byte >> 4, 4) * (1 << shift_left);
                next_right_sample = sign_extend(byte,      4) * (1 << shift_right);
1447

1448 1449
                next_left_sample = (next_left_sample +
                    (current_left_sample * coeff1l) +
1450
                    (previous_left_sample * coeff2l) + 0x80) >> 8;
1451 1452
                next_right_sample = (next_right_sample +
                    (current_right_sample * coeff1r) +
1453 1454 1455
                    (previous_right_sample * coeff2r) + 0x80) >> 8;

                previous_left_sample = current_left_sample;
1456
                current_left_sample = av_clip_int16(next_left_sample);
1457
                previous_right_sample = current_right_sample;
1458
                current_right_sample = av_clip_int16(next_right_sample);
1459 1460
                *samples++ = current_left_sample;
                *samples++ = current_right_sample;
1461 1462
            }
        }
1463

1464
        bytestream2_skip(&gb, 2); // Skip terminating 0x0000
1465

1466
        break;
1467
    }
1468
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
1469 1470 1471
    {
        int coeff[2][2], shift[2];

1472
        for(channel = 0; channel < avctx->channels; channel++) {
1473
            int byte = bytestream2_get_byteu(&gb);
1474
            for (i=0; i<2; i++)
1475 1476
                coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
            shift[channel] = 20 - (byte & 0x0F);
1477
        }
1478
        for (count1 = 0; count1 < nb_samples / 2; count1++) {
1479 1480 1481 1482
            int byte[2];

            byte[0] = bytestream2_get_byteu(&gb);
            if (st) byte[1] = bytestream2_get_byteu(&gb);
1483 1484
            for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
                for(channel = 0; channel < avctx->channels; channel++) {
1485
                    int sample = sign_extend(byte[channel] >> i, 4) * (1 << shift[channel]);
1486 1487 1488 1489 1490 1491 1492 1493 1494
                    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;
                }
            }
        }
1495
        bytestream2_seek(&gb, 0, SEEK_END);
1496
        break;
1497
    }
1498 1499 1500
    case AV_CODEC_ID_ADPCM_EA_R1:
    case AV_CODEC_ID_ADPCM_EA_R2:
    case AV_CODEC_ID_ADPCM_EA_R3: {
1501 1502 1503 1504
        /* 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 */
1505
        const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1506 1507 1508
        int previous_sample, current_sample, next_sample;
        int coeff1, coeff2;
        int shift;
1509 1510
        unsigned int channel;
        uint16_t *samplesC;
1511
        int count = 0;
1512
        int offsets[6];
1513

1514 1515 1516 1517
        for (channel=0; channel<avctx->channels; channel++)
            offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
                                             bytestream2_get_le32(&gb)) +
                               (avctx->channels + 1) * 4;
1518 1519

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

1523
            if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1524 1525
                current_sample  = sign_extend(bytestream2_get_le16(&gb), 16);
                previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1526 1527 1528 1529 1530
            } else {
                current_sample  = c->status[channel].predictor;
                previous_sample = c->status[channel].prev_sample;
            }

1531
            for (count1 = 0; count1 < nb_samples / 28; count1++) {
1532 1533 1534 1535
                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);
1536

1537 1538
                    for (count2=0; count2<28; count2++)
                        *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
1539
                } else {
1540 1541 1542
                    coeff1 = ea_adpcm_table[ byte >> 4     ];
                    coeff2 = ea_adpcm_table[(byte >> 4) + 4];
                    shift = 20 - (byte & 0x0F);
1543 1544 1545

                    for (count2=0; count2<28; count2++) {
                        if (count2 & 1)
1546
                            next_sample = (unsigned)sign_extend(byte,    4) << shift;
1547 1548
                        else {
                            byte = bytestream2_get_byte(&gb);
1549
                            next_sample = (unsigned)sign_extend(byte >> 4, 4) << shift;
1550
                        }
1551 1552 1553 1554 1555 1556 1557

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

                        previous_sample = current_sample;
                        current_sample  = next_sample;
1558
                        *samplesC++ = current_sample;
1559 1560 1561
                    }
                }
            }
1562 1563 1564 1565 1566 1567
            if (!count) {
                count = count1;
            } else if (count != count1) {
                av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
                count = FFMAX(count, count1);
            }
1568

1569
            if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1570 1571 1572 1573 1574
                c->status[channel].predictor   = current_sample;
                c->status[channel].prev_sample = previous_sample;
            }
        }

1575
        frame->nb_samples = count * 28;
1576
        bytestream2_seek(&gb, 0, SEEK_END);
1577 1578
        break;
    }
1579
    case AV_CODEC_ID_ADPCM_EA_XAS:
1580 1581
        for (channel=0; channel<avctx->channels; channel++) {
            int coeff[2][4], shift[4];
1582 1583
            int16_t *s = samples_p[channel];
            for (n = 0; n < 4; n++, s += 32) {
1584
                int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1585
                for (i=0; i<2; i++)
1586 1587 1588 1589 1590
                    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);
1591
                s[1] = val & ~0x0F;
1592 1593 1594
            }

            for (m=2; m<32; m+=2) {
1595 1596 1597
                s = &samples_p[channel][m];
                for (n = 0; n < 4; n++, s += 32) {
                    int level, pred;
1598
                    int byte = bytestream2_get_byteu(&gb);
1599

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

1604
                    level = sign_extend(byte, 4) * (1 << shift[n]);
1605 1606
                    pred  = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
                    s[1]  = av_clip_int16((level + pred + 0x80) >> 8);
1607 1608 1609 1610
                }
            }
        }
        break;
1611
    case AV_CODEC_ID_ADPCM_IMA_AMV:
1612
        c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1613 1614
        c->status[0].step_index = bytestream2_get_byteu(&gb);
        bytestream2_skipu(&gb, 5);
1615 1616 1617 1618
        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;
1619
        }
Vitor Sessak's avatar
Vitor Sessak committed
1620

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

1624 1625 1626 1627 1628
            *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:
1629
        for (i = 0; i < avctx->channels; i++) {
1630 1631 1632 1633 1634 1635 1636 1637
            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;
            }
1638
        }
1639 1640 1641

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

1643 1644
            *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4 );
            *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf);
1645 1646
        }
        break;
1647
    case AV_CODEC_ID_ADPCM_CT:
1648 1649
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v = bytestream2_get_byteu(&gb);
1650 1651
            *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4  );
            *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1652 1653
        }
        break;
1654 1655 1656
    case AV_CODEC_ID_ADPCM_SBPRO_4:
    case AV_CODEC_ID_ADPCM_SBPRO_3:
    case AV_CODEC_ID_ADPCM_SBPRO_2:
1657 1658
        if (!c->status[0].step_index) {
            /* the first byte is a raw sample */
1659
            *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1660
            if (st)
1661
                *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1662
            c->status[0].step_index = 1;
1663
            nb_samples--;
1664
        }
1665
        if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1666 1667
            for (n = nb_samples >> (1 - st); n > 0; n--) {
                int byte = bytestream2_get_byteu(&gb);
1668
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1669
                                                       byte >> 4,   4, 0);
1670
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1671
                                                       byte & 0x0F, 4, 0);
1672
            }
1673
        } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1674
            for (n = (nb_samples<<st) / 3; n > 0; n--) {
1675
                int byte = bytestream2_get_byteu(&gb);
1676
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1677
                                                        byte >> 5        , 3, 0);
1678
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1679
                                                       (byte >> 2) & 0x07, 3, 0);
1680
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1681
                                                        byte & 0x03,       2, 0);
1682 1683
            }
        } else {
1684 1685
            for (n = nb_samples >> (2 - st); n > 0; n--) {
                int byte = bytestream2_get_byteu(&gb);
1686
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1687
                                                        byte >> 6        , 2, 2);
1688
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1689
                                                       (byte >> 4) & 0x03, 2, 2);
1690
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1691
                                                       (byte >> 2) & 0x03, 2, 2);
1692
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1693
                                                        byte & 0x03,       2, 2);
1694 1695 1696
            }
        }
        break;
1697
    case AV_CODEC_ID_ADPCM_SWF:
1698 1699
        adpcm_swf_decode(avctx, buf, buf_size, samples);
        bytestream2_seek(&gb, 0, SEEK_END);
1700
        break;
1701
    case AV_CODEC_ID_ADPCM_YAMAHA:
1702 1703
        for (n = nb_samples >> (1 - st); n > 0; n--) {
            int v = bytestream2_get_byteu(&gb);
1704 1705
            *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
            *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4  );
1706 1707
        }
        break;
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722
    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
1723
    case AV_CODEC_ID_ADPCM_AFC:
Paul B Mahol's avatar
Paul B Mahol committed
1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
    {
        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
1737 1738 1739 1740
        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
1741
            samples = samples_p[channel] + m * 16;
Paul B Mahol's avatar
Paul B Mahol committed
1742
            /* Read in every sample for this channel.  */
Paul B Mahol's avatar
Paul B Mahol committed
1743
            for (i = 0; i < samples_per_block; i++) {
Paul B Mahol's avatar
Paul B Mahol committed
1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760
                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);
                    }

1761 1762
                    sampledat = ((prev1 * factor1 + prev2 * factor2) >> 11) +
                                sampledat * scale;
Paul B Mahol's avatar
Paul B Mahol committed
1763 1764 1765 1766 1767 1768 1769 1770 1771
                    *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
1772
        }
Paul B Mahol's avatar
Paul B Mahol committed
1773 1774
        bytestream2_seek(&gb, 0, SEEK_END);
        break;
Paul B Mahol's avatar
Paul B Mahol committed
1775
    }
1776
    case AV_CODEC_ID_ADPCM_THP:
1777
    case AV_CODEC_ID_ADPCM_THP_LE:
1778
    {
1779
        int table[14][16];
1780 1781
        int ch;

1782 1783 1784 1785 1786 1787
#define THP_GET16(g) \
    sign_extend( \
        avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE ? \
        bytestream2_get_le16u(&(g)) : \
        bytestream2_get_be16u(&(g)), 16)

1788 1789 1790 1791 1792 1793 1794 1795 1796 1797
        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++)
1798
                    table[i][n] = THP_GET16(tb);
1799
        } else {
1800 1801 1802
            for (i = 0; i < avctx->channels; i++)
                for (n = 0; n < 16; n++)
                    table[i][n] = THP_GET16(gb);
1803

1804 1805 1806 1807 1808 1809 1810 1811 1812
            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);
1813
            }
1814
        }
1815

1816
        for (ch = 0; ch < avctx->channels; ch++) {
1817
            samples = samples_p[ch];
1818 1819

            /* Read in every sample for this channel.  */
1820
            for (i = 0; i < (nb_samples + 13) / 14; i++) {
1821 1822 1823
                int byte = bytestream2_get_byteu(&gb);
                int index = (byte >> 4) & 7;
                unsigned int exp = byte & 0x0F;
1824 1825
                int factor1 = table[ch][index * 2];
                int factor2 = table[ch][index * 2 + 1];
1826 1827

                /* Decode 14 samples.  */
1828
                for (n = 0; n < 14 && (i * 14 + n < nb_samples); n++) {
1829
                    int32_t sampledat;
1830 1831 1832 1833 1834 1835 1836

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

1838
                    sampledat = ((c->status[ch].sample1 * factor1
1839
                                + c->status[ch].sample2 * factor2) >> 11) + sampledat * (1 << exp);
1840
                    *samples = av_clip_int16(sampledat);
1841 1842
                    c->status[ch].sample2 = c->status[ch].sample1;
                    c->status[ch].sample1 = *samples++;
1843 1844 1845 1846
                }
            }
        }
        break;
1847
    }
James Almer's avatar
James Almer committed
1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
    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;
                    }

1878
                    prev = av_clip_intp2((prev + 0x20) >> 6, 21);
James Almer's avatar
James Almer committed
1879 1880 1881 1882 1883 1884 1885

                    byte = bytestream2_get_byteu(&gb);
                    if (!channel)
                        sampledat = sign_extend(byte, 4);
                    else
                        sampledat = sign_extend(byte >> 4, 4);

1886
                    sampledat = ((sampledat * (1 << 12)) >> (header & 0xf)) * (1 << 6) + prev;
James Almer's avatar
James Almer committed
1887 1888 1889 1890 1891 1892 1893 1894 1895
                    *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;
1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922
    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);
                        }

1923
                        scale  = scale * (1 << 12);
1924 1925 1926 1927 1928 1929 1930 1931 1932
                        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;
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951
    case AV_CODEC_ID_ADPCM_ARGO:
        /*
         * The format of each block:
         *   uint8_t left_control;
         *   uint4_t left_samples[nb_samples];
         *   ---- and if stereo ----
         *   uint8_t right_control;
         *   uint4_t right_samples[nb_samples];
         *
         * Format of the control byte:
         * MSB [SSSSDRRR] LSB
         *   S = (Shift Amount - 2)
         *   D = Decoder flag.
         *   R = Reserved
         *
         * Each block relies on the previous two samples of each channel.
         * They should be 0 initially.
         */
        for (channel = 0; channel < avctx->channels; channel++) {
1952
            int control, shift;
1953 1954 1955

            samples = samples_p[channel];
            cs = c->status + channel;
1956

1957 1958 1959 1960 1961
            /* Get the control byte and decode the samples, 2 at a time. */
            control = bytestream2_get_byteu(&gb);
            shift = (control >> 4) + 2;

            for (n = 0; n < nb_samples / 2; n++) {
1962 1963 1964
                int sample = bytestream2_get_byteu(&gb);
                *samples++ = adpcm_argo_expand_nibble(cs, sign_extend(sample >> 4, 4), control, shift);
                *samples++ = adpcm_argo_expand_nibble(cs, sign_extend(sample >> 0, 4), control, shift);
1965 1966 1967
            }
        }
        break;
1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980
    case AV_CODEC_ID_ADPCM_ZORK:
        if (!c->has_status) {
            for (channel = 0; channel < avctx->channels; channel++) {
                c->status[channel].predictor  = 0;
                c->status[channel].step_index = 0;
            }
            c->has_status = 1;
        }
        for (n = 0; n < nb_samples * avctx->channels; n++) {
            int v = bytestream2_get_byteu(&gb);
            *samples++ = adpcm_zork_expand_nibble(&c->status[n % avctx->channels], v);
        }
        break;
1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
    case AV_CODEC_ID_ADPCM_IMA_MTF:
        for (n = nb_samples / 2; n > 0; n--) {
            for (channel = 0; channel < avctx->channels; channel++) {
                int v = bytestream2_get_byteu(&gb);
                *samples++  = adpcm_ima_mtf_expand_nibble(&c->status[channel], v >> 4);
                samples[st] = adpcm_ima_mtf_expand_nibble(&c->status[channel], v & 0x0F);
            }
            samples += avctx->channels;
        }
        break;
1991
    default:
1992
        av_assert0(0); // unsupported codec_id should not happen
1993
    }
1994

1995 1996 1997 1998 1999
    if (avpkt->size && bytestream2_tell(&gb) == 0) {
        av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n");
        return AVERROR_INVALIDDATA;
    }

2000
    *got_frame_ptr = 1;
2001

2002 2003 2004 2005 2006
    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;
    }

2007
    return bytestream2_tell(&gb);
2008 2009
}

2010 2011 2012 2013 2014 2015
static void adpcm_flush(AVCodecContext *avctx)
{
    ADPCMDecodeContext *c = avctx->priv_data;
    c->has_status = 0;
}

2016

2017 2018
static const enum AVSampleFormat sample_fmts_s16[]  = { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_NONE };
2019
static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16P,
2020
                                                        AV_SAMPLE_FMT_NONE };
2021 2022 2023
static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_S16P,
                                                        AV_SAMPLE_FMT_NONE };
2024 2025

#define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \
2026 2027
AVCodec ff_ ## name_ ## _decoder = {                        \
    .name           = #name_,                               \
2028
    .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
2029 2030 2031 2032 2033
    .type           = AVMEDIA_TYPE_AUDIO,                   \
    .id             = id_,                                  \
    .priv_data_size = sizeof(ADPCMDecodeContext),           \
    .init           = adpcm_decode_init,                    \
    .decode         = adpcm_decode_frame,                   \
2034
    .flush          = adpcm_flush,                          \
2035
    .capabilities   = AV_CODEC_CAP_DR1,                     \
2036
    .sample_fmts    = sample_fmts_,                         \
2037
}
2038

2039
/* Note: Do not forget to add new entries to the Makefile as well. */
2040
ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM,         sample_fmts_s16p, adpcm_4xm,         "ADPCM 4X Movie");
Paul B Mahol's avatar
Paul B Mahol committed
2041
ADPCM_DECODER(AV_CODEC_ID_ADPCM_AFC,         sample_fmts_s16p, adpcm_afc,         "ADPCM Nintendo Gamecube AFC");
2042
ADPCM_DECODER(AV_CODEC_ID_ADPCM_AGM,         sample_fmts_s16,  adpcm_agm,         "ADPCM AmuseGraphics Movie");
2043
ADPCM_DECODER(AV_CODEC_ID_ADPCM_AICA,        sample_fmts_s16p, adpcm_aica,        "ADPCM Yamaha AICA");
2044
ADPCM_DECODER(AV_CODEC_ID_ADPCM_ARGO,        sample_fmts_s16p, adpcm_argo,        "ADPCM Argonaut Games");
2045
ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT,          sample_fmts_s16,  adpcm_ct,          "ADPCM Creative Technology");
James Almer's avatar
James Almer committed
2046
ADPCM_DECODER(AV_CODEC_ID_ADPCM_DTK,         sample_fmts_s16p, adpcm_dtk,         "ADPCM Nintendo Gamecube DTK");
2047 2048
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");
2049 2050 2051
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");
2052
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS,      sample_fmts_s16p, adpcm_ea_xas,      "ADPCM Electronic Arts XAS");
2053 2054
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");
2055
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APM,     sample_fmts_s16,  adpcm_ima_apm,     "ADPCM IMA Ubisoft APM");
2056
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DAT4,    sample_fmts_s16,  adpcm_ima_dat4,    "ADPCM IMA Eurocom DAT4");
2057 2058 2059 2060 2061
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");
2062
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_MTF,     sample_fmts_s16,  adpcm_ima_mtf,     "ADPCM IMA Capcom's MT Framework");
2063
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_OKI,     sample_fmts_s16,  adpcm_ima_oki,     "ADPCM IMA Dialogic OKI");
2064
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT,      sample_fmts_s16p, adpcm_ima_qt,      "ADPCM IMA QuickTime");
James Almer's avatar
James Almer committed
2065
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_RAD,     sample_fmts_s16,  adpcm_ima_rad,     "ADPCM IMA Radical");
2066
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SSI,     sample_fmts_s16,  adpcm_ima_ssi,     "ADPCM IMA Simon & Schuster Interactive");
2067
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG,  sample_fmts_s16,  adpcm_ima_smjpeg,  "ADPCM IMA Loki SDL MJPEG");
2068
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ALP,     sample_fmts_s16,  adpcm_ima_alp,     "ADPCM IMA High Voltage Software ALP");
2069
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV,     sample_fmts_s16p, adpcm_ima_wav,     "ADPCM IMA WAV");
2070
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS,      sample_fmts_both, adpcm_ima_ws,      "ADPCM IMA Westwood");
2071
ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS,          sample_fmts_both, adpcm_ms,          "ADPCM Microsoft");
2072
ADPCM_DECODER(AV_CODEC_ID_ADPCM_MTAF,        sample_fmts_s16p, adpcm_mtaf,        "ADPCM MTAF");
2073
ADPCM_DECODER(AV_CODEC_ID_ADPCM_PSX,         sample_fmts_s16p, adpcm_psx,         "ADPCM Playstation");
2074 2075 2076 2077
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");
2078 2079
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");
2080
ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA,          sample_fmts_s16p, adpcm_xa,          "ADPCM CDROM XA");
2081
ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA,      sample_fmts_s16,  adpcm_yamaha,      "ADPCM Yamaha");
2082
ADPCM_DECODER(AV_CODEC_ID_ADPCM_ZORK,        sample_fmts_s16,  adpcm_zork,        "ADPCM Zork");