git.sesse.net Git - ffmpeg/blob - libavcodec/adpcm.c

   1 /*
   2  * Copyright (c) 2001-2003 The FFmpeg project
   3  *
   4  * first version by Francois Revol (revol@free.fr)
   5  * fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
   6  *   by Mike Melanson (melanson@pcisys.net)
   7  * CD-ROM XA ADPCM codec by BERO
   8  * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com)
   9  * EA ADPCM R1/R2/R3 decoder by Peter Ross (pross@xvid.org)
  10  * EA IMA EACS decoder by Peter Ross (pross@xvid.org)
  11  * EA IMA SEAD decoder by Peter Ross (pross@xvid.org)
  12  * EA ADPCM XAS decoder by Peter Ross (pross@xvid.org)
  13  * MAXIS EA ADPCM decoder by Robert Marston (rmarston@gmail.com)
  14  * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl)
  15  *
  16  * This file is part of FFmpeg.
  17  *
  18  * FFmpeg is free software; you can redistribute it and/or
  19  * modify it under the terms of the GNU Lesser General Public
  20  * License as published by the Free Software Foundation; either
  21  * version 2.1 of the License, or (at your option) any later version.
  22  *
  23  * FFmpeg is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  26  * Lesser General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU Lesser General Public
  29  * License along with FFmpeg; if not, write to the Free Software
  30  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  31  */
  32 #include "avcodec.h"
  33 #include "get_bits.h"
  34 #include "bytestream.h"
  35 #include "adpcm.h"
  36 #include "adpcm_data.h"
  37 #include "internal.h"
  38
  39 /**
  40  * @file
  41  * ADPCM decoders
  42  * Features and limitations:
  43  *
  44  * Reference documents:
  45  * http://wiki.multimedia.cx/index.php?title=Category:ADPCM_Audio_Codecs
  46  * http://www.pcisys.net/~melanson/codecs/simpleaudio.html [dead]
  47  * http://www.geocities.com/SiliconValley/8682/aud3.txt [dead]
  48  * http://openquicktime.sourceforge.net/
  49  * XAnim sources (xa_codec.c) http://xanim.polter.net/
  50  * http://www.cs.ucla.edu/~leec/mediabench/applications.html [dead]
  51  * SoX source code http://sox.sourceforge.net/
  52  *
  53  * CD-ROM XA:
  54  * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html [dead]
  55  * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html [dead]
  56  * readstr http://www.geocities.co.jp/Playtown/2004/
  57  */
  58
  59 /* These are for CD-ROM XA ADPCM */
  60 static const int8_t xa_adpcm_table[5][2] = {
  61     {   0,   0 },
  62     {  60,   0 },
  63     { 115, -52 },
  64     {  98, -55 },
  65     { 122, -60 }
  66 };
  67
  68 static const int16_t ea_adpcm_table[] = {
  69     0,  240,  460,  392,
  70     0,    0, -208, -220,
  71     0,    1,    3,    4,
  72     7,    8,   10,   11,
  73     0,   -1,   -3,   -4
  74 };
  75
  76 // padded to zero where table size is less then 16
  77 static const int8_t swf_index_tables[4][16] = {
  78     /*2*/ { -1, 2 },
  79     /*3*/ { -1, -1, 2, 4 },
  80     /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },
  81     /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
  82 };
  83
  84 /* end of tables */
  85
  86 typedef struct ADPCMDecodeContext {
  87     ADPCMChannelStatus status[14];
  88     int vqa_version;                /**< VQA version. Used for ADPCM_IMA_WS */
  89     int has_status;
  90 } ADPCMDecodeContext;
  91
  92 static av_cold int adpcm_decode_init(AVCodecContext * avctx)
  93 {
  94     ADPCMDecodeContext *c = avctx->priv_data;
  95     unsigned int min_channels = 1;
  96     unsigned int max_channels = 2;
  97
  98     switch(avctx->codec->id) {
  99     case AV_CODEC_ID_ADPCM_DTK:
 100     case AV_CODEC_ID_ADPCM_EA:
 101         min_channels = 2;
 102         break;
 103     case AV_CODEC_ID_ADPCM_AFC:
 104     case AV_CODEC_ID_ADPCM_EA_R1:
 105     case AV_CODEC_ID_ADPCM_EA_R2:
 106     case AV_CODEC_ID_ADPCM_EA_R3:
 107     case AV_CODEC_ID_ADPCM_EA_XAS:
 108     case AV_CODEC_ID_ADPCM_MS:
 109         max_channels = 6;
 110         break;
 111     case AV_CODEC_ID_ADPCM_MTAF:
 112         min_channels = 2;
 113         max_channels = 8;
 114         if (avctx->channels & 1) {
 115             avpriv_request_sample(avctx, "channel count %d\n", avctx->channels);
 116             return AVERROR_PATCHWELCOME;
 117         }
 118         break;
 119     case AV_CODEC_ID_ADPCM_PSX:
 120         max_channels = 8;
 121         break;
 122     case AV_CODEC_ID_ADPCM_IMA_DAT4:
 123     case AV_CODEC_ID_ADPCM_THP:
 124     case AV_CODEC_ID_ADPCM_THP_LE:
 125         max_channels = 14;
 126         break;
 127     }
 128     if (avctx->channels < min_channels || avctx->channels > max_channels) {
 129         av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
 130         return AVERROR(EINVAL);
 131     }
 132
 133     switch(avctx->codec->id) {
 134     case AV_CODEC_ID_ADPCM_CT:
 135         c->status[0].step = c->status[1].step = 511;
 136         break;
 137     case AV_CODEC_ID_ADPCM_IMA_WAV:
 138         if (avctx->bits_per_coded_sample < 2 || avctx->bits_per_coded_sample > 5)
 139             return AVERROR_INVALIDDATA;
 140         break;
 141     case AV_CODEC_ID_ADPCM_IMA_APC:
 142         if (avctx->extradata && avctx->extradata_size >= 8) {
 143             c->status[0].predictor = AV_RL32(avctx->extradata);
 144             c->status[1].predictor = AV_RL32(avctx->extradata + 4);
 145         }
 146         break;
 147     case AV_CODEC_ID_ADPCM_IMA_WS:
 148         if (avctx->extradata && avctx->extradata_size >= 2)
 149             c->vqa_version = AV_RL16(avctx->extradata);
 150         break;
 151     default:
 152         break;
 153     }
 154
 155     switch(avctx->codec->id) {
 156         case AV_CODEC_ID_ADPCM_AICA:
 157         case AV_CODEC_ID_ADPCM_IMA_DAT4:
 158         case AV_CODEC_ID_ADPCM_IMA_QT:
 159         case AV_CODEC_ID_ADPCM_IMA_WAV:
 160         case AV_CODEC_ID_ADPCM_4XM:
 161         case AV_CODEC_ID_ADPCM_XA:
 162         case AV_CODEC_ID_ADPCM_EA_R1:
 163         case AV_CODEC_ID_ADPCM_EA_R2:
 164         case AV_CODEC_ID_ADPCM_EA_R3:
 165         case AV_CODEC_ID_ADPCM_EA_XAS:
 166         case AV_CODEC_ID_ADPCM_THP:
 167         case AV_CODEC_ID_ADPCM_THP_LE:
 168         case AV_CODEC_ID_ADPCM_AFC:
 169         case AV_CODEC_ID_ADPCM_DTK:
 170         case AV_CODEC_ID_ADPCM_PSX:
 171         case AV_CODEC_ID_ADPCM_MTAF:
 172             avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
 173             break;
 174         case AV_CODEC_ID_ADPCM_IMA_WS:
 175             avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
 176                                                       AV_SAMPLE_FMT_S16;
 177             break;
 178         case AV_CODEC_ID_ADPCM_MS:
 179             avctx->sample_fmt = avctx->channels > 2 ? AV_SAMPLE_FMT_S16P :
 180                                                       AV_SAMPLE_FMT_S16;
 181             break;
 182         default:
 183             avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 184     }
 185
 186     return 0;
 187 }
 188
 189 static inline int16_t adpcm_agm_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
 190 {
 191     int delta, pred, step, add;
 192
 193     pred = c->predictor;
 194     delta = nibble & 7;
 195     step = c->step;
 196     add = (delta * 2 + 1) * step;
 197     if (add < 0)
 198         add = add + 7;
 199
 200     if ((nibble & 8) == 0)
 201         pred = av_clip(pred + (add >> 3), -32767, 32767);
 202     else
 203         pred = av_clip(pred - (add >> 3), -32767, 32767);
 204
 205     switch (delta) {
 206     case 7:
 207         step *= 0x99;
 208         break;
 209     case 6:
 210         c->step = av_clip(c->step * 2, 127, 24576);
 211         c->predictor = pred;
 212         return pred;
 213     case 5:
 214         step *= 0x66;
 215         break;
 216     case 4:
 217         step *= 0x4d;
 218         break;
 219     default:
 220         step *= 0x39;
 221         break;
 222     }
 223
 224     if (step < 0)
 225         step += 0x3f;
 226
 227     c->step = step >> 6;
 228     c->step = av_clip(c->step, 127, 24576);
 229     c->predictor = pred;
 230     return pred;
 231 }
 232
 233 static inline int16_t adpcm_ima_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
 234 {
 235     int step_index;
 236     int predictor;
 237     int sign, delta, diff, step;
 238
 239     step = ff_adpcm_step_table[c->step_index];
 240     step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
 241     step_index = av_clip(step_index, 0, 88);
 242
 243     sign = nibble & 8;
 244     delta = nibble & 7;
 245     /* perform direct multiplication instead of series of jumps proposed by
 246      * the reference ADPCM implementation since modern CPUs can do the mults
 247      * quickly enough */
 248     diff = ((2 * delta + 1) * step) >> shift;
 249     predictor = c->predictor;
 250     if (sign) predictor -= diff;
 251     else predictor += diff;
 252
 253     c->predictor = av_clip_int16(predictor);
 254     c->step_index = step_index;
 255
 256     return (int16_t)c->predictor;
 257 }
 258
 259 static inline int16_t adpcm_ima_wav_expand_nibble(ADPCMChannelStatus *c, GetBitContext *gb, int bps)
 260 {
 261     int nibble, step_index, predictor, sign, delta, diff, step, shift;
 262
 263     shift = bps - 1;
 264     nibble = get_bits_le(gb, bps),
 265     step = ff_adpcm_step_table[c->step_index];
 266     step_index = c->step_index + ff_adpcm_index_tables[bps - 2][nibble];
 267     step_index = av_clip(step_index, 0, 88);
 268
 269     sign = nibble & (1 << shift);
 270     delta = av_mod_uintp2(nibble, shift);
 271     diff = ((2 * delta + 1) * step) >> shift;
 272     predictor = c->predictor;
 273     if (sign) predictor -= diff;
 274     else predictor += diff;
 275
 276     c->predictor = av_clip_int16(predictor);
 277     c->step_index = step_index;
 278
 279     return (int16_t)c->predictor;
 280 }
 281
 282 static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)
 283 {
 284     int step_index;
 285     int predictor;
 286     int diff, step;
 287
 288     step = ff_adpcm_step_table[c->step_index];
 289     step_index = c->step_index + ff_adpcm_index_table[nibble];
 290     step_index = av_clip(step_index, 0, 88);
 291
 292     diff = step >> 3;
 293     if (nibble & 4) diff += step;
 294     if (nibble & 2) diff += step >> 1;
 295     if (nibble & 1) diff += step >> 2;
 296
 297     if (nibble & 8)
 298         predictor = c->predictor - diff;
 299     else
 300         predictor = c->predictor + diff;
 301
 302     c->predictor = av_clip_int16(predictor);
 303     c->step_index = step_index;
 304
 305     return c->predictor;
 306 }
 307
 308 static inline int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
 309 {
 310     int predictor;
 311
 312     predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
 313     predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
 314
 315     c->sample2 = c->sample1;
 316     c->sample1 = av_clip_int16(predictor);
 317     c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
 318     if (c->idelta < 16) c->idelta = 16;
 319     if (c->idelta > INT_MAX/768) {
 320         av_log(NULL, AV_LOG_WARNING, "idelta overflow\n");
 321         c->idelta = INT_MAX/768;
 322     }
 323
 324     return c->sample1;
 325 }
 326
 327 static inline int16_t adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)
 328 {
 329     int step_index, predictor, sign, delta, diff, step;
 330
 331     step = ff_adpcm_oki_step_table[c->step_index];
 332     step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
 333     step_index = av_clip(step_index, 0, 48);
 334
 335     sign = nibble & 8;
 336     delta = nibble & 7;
 337     diff = ((2 * delta + 1) * step) >> 3;
 338     predictor = c->predictor;
 339     if (sign) predictor -= diff;
 340     else predictor += diff;
 341
 342     c->predictor = av_clip_intp2(predictor, 11);
 343     c->step_index = step_index;
 344
 345     return c->predictor << 4;
 346 }
 347
 348 static inline int16_t adpcm_ct_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
 349 {
 350     int sign, delta, diff;
 351     int new_step;
 352
 353     sign = nibble & 8;
 354     delta = nibble & 7;
 355     /* perform direct multiplication instead of series of jumps proposed by
 356      * the reference ADPCM implementation since modern CPUs can do the mults
 357      * quickly enough */
 358     diff = ((2 * delta + 1) * c->step) >> 3;
 359     /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
 360     c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
 361     c->predictor = av_clip_int16(c->predictor);
 362     /* calculate new step and clamp it to range 511..32767 */
 363     new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
 364     c->step = av_clip(new_step, 511, 32767);
 365
 366     return (int16_t)c->predictor;
 367 }
 368
 369 static inline int16_t adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int size, int shift)
 370 {
 371     int sign, delta, diff;
 372
 373     sign = nibble & (1<<(size-1));
 374     delta = nibble & ((1<<(size-1))-1);
 375     diff = delta << (7 + c->step + shift);
 376
 377     /* clamp result */
 378     c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
 379
 380     /* calculate new step */
 381     if (delta >= (2*size - 3) && c->step < 3)
 382         c->step++;
 383     else if (delta == 0 && c->step > 0)
 384         c->step--;
 385
 386     return (int16_t) c->predictor;
 387 }
 388
 389 static inline int16_t adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
 390 {
 391     if(!c->step) {
 392         c->predictor = 0;
 393         c->step = 127;
 394     }
 395
 396     c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
 397     c->predictor = av_clip_int16(c->predictor);
 398     c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
 399     c->step = av_clip(c->step, 127, 24576);
 400     return c->predictor;
 401 }
 402
 403 static inline int16_t adpcm_mtaf_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
 404 {
 405     c->predictor += ff_adpcm_mtaf_stepsize[c->step][nibble];
 406     c->predictor = av_clip_int16(c->predictor);
 407     c->step += ff_adpcm_index_table[nibble];
 408     c->step = av_clip_uintp2(c->step, 5);
 409     return c->predictor;
 410 }
 411
 412 static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
 413                      const uint8_t *in, ADPCMChannelStatus *left,
 414                      ADPCMChannelStatus *right, int channels, int sample_offset)
 415 {
 416     int i, j;
 417     int shift,filter,f0,f1;
 418     int s_1,s_2;
 419     int d,s,t;
 420
 421     out0 += sample_offset;
 422     if (channels == 1)
 423         out1 = out0 + 28;
 424     else
 425         out1 += sample_offset;
 426
 427     for(i=0;i<4;i++) {
 428         shift  = 12 - (in[4+i*2] & 15);
 429         filter = in[4+i*2] >> 4;
 430         if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
 431             avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
 432             filter=0;
 433         }
 434         f0 = xa_adpcm_table[filter][0];
 435         f1 = xa_adpcm_table[filter][1];
 436
 437         s_1 = left->sample1;
 438         s_2 = left->sample2;
 439
 440         for(j=0;j<28;j++) {
 441             d = in[16+i+j*4];
 442
 443             t = sign_extend(d, 4);
 444             s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
 445             s_2 = s_1;
 446             s_1 = av_clip_int16(s);
 447             out0[j] = s_1;
 448         }
 449
 450         if (channels == 2) {
 451             left->sample1 = s_1;
 452             left->sample2 = s_2;
 453             s_1 = right->sample1;
 454             s_2 = right->sample2;
 455         }
 456
 457         shift  = 12 - (in[5+i*2] & 15);
 458         filter = in[5+i*2] >> 4;
 459         if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
 460             avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
 461             filter=0;
 462         }
 463
 464         f0 = xa_adpcm_table[filter][0];
 465         f1 = xa_adpcm_table[filter][1];
 466
 467         for(j=0;j<28;j++) {
 468             d = in[16+i+j*4];
 469
 470             t = sign_extend(d >> 4, 4);
 471             s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
 472             s_2 = s_1;
 473             s_1 = av_clip_int16(s);
 474             out1[j] = s_1;
 475         }
 476
 477         if (channels == 2) {
 478             right->sample1 = s_1;
 479             right->sample2 = s_2;
 480         } else {
 481             left->sample1 = s_1;
 482             left->sample2 = s_2;
 483         }
 484
 485         out0 += 28 * (3 - channels);
 486         out1 += 28 * (3 - channels);
 487     }
 488
 489     return 0;
 490 }
 491
 492 static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
 493 {
 494     ADPCMDecodeContext *c = avctx->priv_data;
 495     GetBitContext gb;
 496     const int8_t *table;
 497     int k0, signmask, nb_bits, count;
 498     int size = buf_size*8;
 499     int i;
 500
 501     init_get_bits(&gb, buf, size);
 502
 503     //read bits & initial values
 504     nb_bits = get_bits(&gb, 2)+2;
 505     table = swf_index_tables[nb_bits-2];
 506     k0 = 1 << (nb_bits-2);
 507     signmask = 1 << (nb_bits-1);
 508
 509     while (get_bits_count(&gb) <= size - 22*avctx->channels) {
 510         for (i = 0; i < avctx->channels; i++) {
 511             *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
 512             c->status[i].step_index = get_bits(&gb, 6);
 513         }
 514
 515         for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
 516             int i;
 517
 518             for (i = 0; i < avctx->channels; i++) {
 519                 // similar to IMA adpcm
 520                 int delta = get_bits(&gb, nb_bits);
 521                 int step = ff_adpcm_step_table[c->status[i].step_index];
 522                 int vpdiff = 0; // vpdiff = (delta+0.5)*step/4
 523                 int k = k0;
 524
 525                 do {
 526                     if (delta & k)
 527                         vpdiff += step;
 528                     step >>= 1;
 529                     k >>= 1;
 530                 } while(k);
 531                 vpdiff += step;
 532
 533                 if (delta & signmask)
 534                     c->status[i].predictor -= vpdiff;
 535                 else
 536                     c->status[i].predictor += vpdiff;
 537
 538                 c->status[i].step_index += table[delta & (~signmask)];
 539
 540                 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
 541                 c->status[i].predictor = av_clip_int16(c->status[i].predictor);
 542
 543                 *samples++ = c->status[i].predictor;
 544             }
 545         }
 546     }
 547 }
 548
 549 /**
 550  * Get the number of samples that will be decoded from the packet.
 551  * In one case, this is actually the maximum number of samples possible to
 552  * decode with the given buf_size.
 553  *
 554  * @param[out] coded_samples set to the number of samples as coded in the
 555  *                           packet, or 0 if the codec does not encode the
 556  *                           number of samples in each frame.
 557  * @param[out] approx_nb_samples set to non-zero if the number of samples
 558  *                               returned is an approximation.
 559  */
 560 static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
 561                           int buf_size, int *coded_samples, int *approx_nb_samples)
 562 {
 563     ADPCMDecodeContext *s = avctx->priv_data;
 564     int nb_samples        = 0;
 565     int ch                = avctx->channels;
 566     int has_coded_samples = 0;
 567     int header_size;
 568
 569     *coded_samples = 0;
 570     *approx_nb_samples = 0;
 571
 572     if(ch <= 0)
 573         return 0;
 574
 575     switch (avctx->codec->id) {
 576     /* constant, only check buf_size */
 577     case AV_CODEC_ID_ADPCM_EA_XAS:
 578         if (buf_size < 76 * ch)
 579             return 0;
 580         nb_samples = 128;
 581         break;
 582     case AV_CODEC_ID_ADPCM_IMA_QT:
 583         if (buf_size < 34 * ch)
 584             return 0;
 585         nb_samples = 64;
 586         break;
 587     /* simple 4-bit adpcm */
 588     case AV_CODEC_ID_ADPCM_CT:
 589     case AV_CODEC_ID_ADPCM_IMA_APC:
 590     case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
 591     case AV_CODEC_ID_ADPCM_IMA_OKI:
 592     case AV_CODEC_ID_ADPCM_IMA_WS:
 593     case AV_CODEC_ID_ADPCM_YAMAHA:
 594     case AV_CODEC_ID_ADPCM_AICA:
 595         nb_samples = buf_size * 2 / ch;
 596         break;
 597     }
 598     if (nb_samples)
 599         return nb_samples;
 600
 601     /* simple 4-bit adpcm, with header */
 602     header_size = 0;
 603     switch (avctx->codec->id) {
 604         case AV_CODEC_ID_ADPCM_4XM:
 605         case AV_CODEC_ID_ADPCM_AGM:
 606         case AV_CODEC_ID_ADPCM_IMA_DAT4:
 607         case AV_CODEC_ID_ADPCM_IMA_ISS:     header_size = 4 * ch;      break;
 608         case AV_CODEC_ID_ADPCM_IMA_AMV:     header_size = 8;           break;
 609         case AV_CODEC_ID_ADPCM_IMA_SMJPEG:  header_size = 4 * ch;      break;
 610     }
 611     if (header_size > 0)
 612         return (buf_size - header_size) * 2 / ch;
 613
 614     /* more complex formats */
 615     switch (avctx->codec->id) {
 616     case AV_CODEC_ID_ADPCM_EA:
 617         has_coded_samples = 1;
 618         *coded_samples  = bytestream2_get_le32(gb);
 619         *coded_samples -= *coded_samples % 28;
 620         nb_samples      = (buf_size - 12) / 30 * 28;
 621         break;
 622     case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
 623         has_coded_samples = 1;
 624         *coded_samples = bytestream2_get_le32(gb);
 625         nb_samples     = (buf_size - (4 + 8 * ch)) * 2 / ch;
 626         break;
 627     case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
 628         nb_samples = (buf_size - ch) / ch * 2;
 629         break;
 630     case AV_CODEC_ID_ADPCM_EA_R1:
 631     case AV_CODEC_ID_ADPCM_EA_R2:
 632     case AV_CODEC_ID_ADPCM_EA_R3:
 633         /* maximum number of samples */
 634         /* has internal offsets and a per-frame switch to signal raw 16-bit */
 635         has_coded_samples = 1;
 636         switch (avctx->codec->id) {
 637         case AV_CODEC_ID_ADPCM_EA_R1:
 638             header_size    = 4 + 9 * ch;
 639             *coded_samples = bytestream2_get_le32(gb);
 640             break;
 641         case AV_CODEC_ID_ADPCM_EA_R2:
 642             header_size    = 4 + 5 * ch;
 643             *coded_samples = bytestream2_get_le32(gb);
 644             break;
 645         case AV_CODEC_ID_ADPCM_EA_R3:
 646             header_size    = 4 + 5 * ch;
 647             *coded_samples = bytestream2_get_be32(gb);
 648             break;
 649         }
 650         *coded_samples -= *coded_samples % 28;
 651         nb_samples      = (buf_size - header_size) * 2 / ch;
 652         nb_samples     -= nb_samples % 28;
 653         *approx_nb_samples = 1;
 654         break;
 655     case AV_CODEC_ID_ADPCM_IMA_DK3:
 656         if (avctx->block_align > 0)
 657             buf_size = FFMIN(buf_size, avctx->block_align);
 658         nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
 659         break;
 660     case AV_CODEC_ID_ADPCM_IMA_DK4:
 661         if (avctx->block_align > 0)
 662             buf_size = FFMIN(buf_size, avctx->block_align);
 663         if (buf_size < 4 * ch)
 664             return AVERROR_INVALIDDATA;
 665         nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
 666         break;
 667     case AV_CODEC_ID_ADPCM_IMA_RAD:
 668         if (avctx->block_align > 0)
 669             buf_size = FFMIN(buf_size, avctx->block_align);
 670         nb_samples = (buf_size - 4 * ch) * 2 / ch;
 671         break;
 672     case AV_CODEC_ID_ADPCM_IMA_WAV:
 673     {
 674         int bsize = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
 675         int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
 676         if (avctx->block_align > 0)
 677             buf_size = FFMIN(buf_size, avctx->block_align);
 678         if (buf_size < 4 * ch)
 679             return AVERROR_INVALIDDATA;
 680         nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;
 681         break;
 682     }
 683     case AV_CODEC_ID_ADPCM_MS:
 684         if (avctx->block_align > 0)
 685             buf_size = FFMIN(buf_size, avctx->block_align);
 686         nb_samples = (buf_size - 6 * ch) * 2 / ch;
 687         break;
 688     case AV_CODEC_ID_ADPCM_MTAF:
 689         if (avctx->block_align > 0)
 690             buf_size = FFMIN(buf_size, avctx->block_align);
 691         nb_samples = (buf_size - 16 * (ch / 2)) * 2 / ch;
 692         break;
 693     case AV_CODEC_ID_ADPCM_SBPRO_2:
 694     case AV_CODEC_ID_ADPCM_SBPRO_3:
 695     case AV_CODEC_ID_ADPCM_SBPRO_4:
 696     {
 697         int samples_per_byte;
 698         switch (avctx->codec->id) {
 699         case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
 700         case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
 701         case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
 702         }
 703         if (!s->status[0].step_index) {
 704             if (buf_size < ch)
 705                 return AVERROR_INVALIDDATA;
 706             nb_samples++;
 707             buf_size -= ch;
 708         }
 709         nb_samples += buf_size * samples_per_byte / ch;
 710         break;
 711     }
 712     case AV_CODEC_ID_ADPCM_SWF:
 713     {
 714         int buf_bits       = buf_size * 8 - 2;
 715         int nbits          = (bytestream2_get_byte(gb) >> 6) + 2;
 716         int block_hdr_size = 22 * ch;
 717         int block_size     = block_hdr_size + nbits * ch * 4095;
 718         int nblocks        = buf_bits / block_size;
 719         int bits_left      = buf_bits - nblocks * block_size;
 720         nb_samples         = nblocks * 4096;
 721         if (bits_left >= block_hdr_size)
 722             nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
 723         break;
 724     }
 725     case AV_CODEC_ID_ADPCM_THP:
 726     case AV_CODEC_ID_ADPCM_THP_LE:
 727         if (avctx->extradata) {
 728             nb_samples = buf_size * 14 / (8 * ch);
 729             break;
 730         }
 731         has_coded_samples = 1;
 732         bytestream2_skip(gb, 4); // channel size
 733         *coded_samples  = (avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE) ?
 734                           bytestream2_get_le32(gb) :
 735                           bytestream2_get_be32(gb);
 736         buf_size       -= 8 + 36 * ch;
 737         buf_size       /= ch;
 738         nb_samples      = buf_size / 8 * 14;
 739         if (buf_size % 8 > 1)
 740             nb_samples     += (buf_size % 8 - 1) * 2;
 741         *approx_nb_samples = 1;
 742         break;
 743     case AV_CODEC_ID_ADPCM_AFC:
 744         nb_samples = buf_size / (9 * ch) * 16;
 745         break;
 746     case AV_CODEC_ID_ADPCM_XA:
 747         nb_samples = (buf_size / 128) * 224 / ch;
 748         break;
 749     case AV_CODEC_ID_ADPCM_DTK:
 750     case AV_CODEC_ID_ADPCM_PSX:
 751         nb_samples = buf_size / (16 * ch) * 28;
 752         break;
 753     }
 754
 755     /* validate coded sample count */
 756     if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
 757         return AVERROR_INVALIDDATA;
 758
 759     return nb_samples;
 760 }
 761
 762 static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
 763                               int *got_frame_ptr, AVPacket *avpkt)
 764 {
 765     AVFrame *frame     = data;
 766     const uint8_t *buf = avpkt->data;
 767     int buf_size = avpkt->size;
 768     ADPCMDecodeContext *c = avctx->priv_data;
 769     ADPCMChannelStatus *cs;
 770     int n, m, channel, i;
 771     int16_t *samples;
 772     int16_t **samples_p;
 773     int st; /* stereo */
 774     int count1, count2;
 775     int nb_samples, coded_samples, approx_nb_samples, ret;
 776     GetByteContext gb;
 777
 778     bytestream2_init(&gb, buf, buf_size);
 779     nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);
 780     if (nb_samples <= 0) {
 781         av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
 782         return AVERROR_INVALIDDATA;
 783     }
 784
 785     /* get output buffer */
 786     frame->nb_samples = nb_samples;
 787     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 788         return ret;
 789     samples = (int16_t *)frame->data[0];
 790     samples_p = (int16_t **)frame->extended_data;
 791
 792     /* use coded_samples when applicable */
 793     /* it is always <= nb_samples, so the output buffer will be large enough */
 794     if (coded_samples) {
 795         if (!approx_nb_samples && coded_samples != nb_samples)
 796             av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
 797         frame->nb_samples = nb_samples = coded_samples;
 798     }
 799
 800     st = avctx->channels == 2 ? 1 : 0;
 801
 802     switch(avctx->codec->id) {
 803     case AV_CODEC_ID_ADPCM_IMA_QT:
 804         /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
 805            Channel data is interleaved per-chunk. */
 806         for (channel = 0; channel < avctx->channels; channel++) {
 807             int predictor;
 808             int step_index;
 809             cs = &(c->status[channel]);
 810             /* (pppppp) (piiiiiii) */
 811
 812             /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
 813             predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
 814             step_index = predictor & 0x7F;
 815             predictor &= ~0x7F;
 816
 817             if (cs->step_index == step_index) {
 818                 int diff = predictor - cs->predictor;
 819                 if (diff < 0)
 820                     diff = - diff;
 821                 if (diff > 0x7f)
 822                     goto update;
 823             } else {
 824             update:
 825                 cs->step_index = step_index;
 826                 cs->predictor = predictor;
 827             }
 828
 829             if (cs->step_index > 88u){
 830                 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
 831                        channel, cs->step_index);
 832                 return AVERROR_INVALIDDATA;
 833             }
 834
 835             samples = samples_p[channel];
 836
 837             for (m = 0; m < 64; m += 2) {
 838                 int byte = bytestream2_get_byteu(&gb);
 839                 samples[m    ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F, 3);
 840                 samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4  , 3);
 841             }
 842         }
 843         break;
 844     case AV_CODEC_ID_ADPCM_IMA_WAV:
 845         for(i=0; i<avctx->channels; i++){
 846             cs = &(c->status[i]);
 847             cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
 848
 849             cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
 850             if (cs->step_index > 88u){
 851                 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
 852                        i, cs->step_index);
 853                 return AVERROR_INVALIDDATA;
 854             }
 855         }
 856
 857         if (avctx->bits_per_coded_sample != 4) {
 858             int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
 859             int block_size = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
 860             uint8_t temp[20 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
 861             GetBitContext g;
 862
 863             for (n = 0; n < (nb_samples - 1) / samples_per_block; n++) {
 864                 for (i = 0; i < avctx->channels; i++) {
 865                     int j;
 866
 867                     cs = &c->status[i];
 868                     samples = &samples_p[i][1 + n * samples_per_block];
 869                     for (j = 0; j < block_size; j++) {
 870                         temp[j] = buf[4 * avctx->channels + block_size * n * avctx->channels +
 871                                         (j % 4) + (j / 4) * (avctx->channels * 4) + i * 4];
 872                     }
 873                     ret = init_get_bits8(&g, (const uint8_t *)&temp, block_size);
 874                     if (ret < 0)
 875                         return ret;
 876                     for (m = 0; m < samples_per_block; m++) {
 877                         samples[m] = adpcm_ima_wav_expand_nibble(cs, &g,
 878                                           avctx->bits_per_coded_sample);
 879                     }
 880                 }
 881             }
 882             bytestream2_skip(&gb, avctx->block_align - avctx->channels * 4);
 883         } else {
 884         for (n = 0; n < (nb_samples - 1) / 8; n++) {
 885             for (i = 0; i < avctx->channels; i++) {
 886                 cs = &c->status[i];
 887                 samples = &samples_p[i][1 + n * 8];
 888                 for (m = 0; m < 8; m += 2) {
 889                     int v = bytestream2_get_byteu(&gb);
 890                     samples[m    ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
 891                     samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
 892                 }
 893             }
 894         }
 895         }
 896         break;
 897     case AV_CODEC_ID_ADPCM_4XM:
 898         for (i = 0; i < avctx->channels; i++)
 899             c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
 900
 901         for (i = 0; i < avctx->channels; i++) {
 902             c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
 903             if (c->status[i].step_index > 88u) {
 904                 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
 905                        i, c->status[i].step_index);
 906                 return AVERROR_INVALIDDATA;
 907             }
 908         }
 909
 910         for (i = 0; i < avctx->channels; i++) {
 911             samples = (int16_t *)frame->data[i];
 912             cs = &c->status[i];
 913             for (n = nb_samples >> 1; n > 0; n--) {
 914                 int v = bytestream2_get_byteu(&gb);
 915                 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
 916                 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4  , 4);
 917             }
 918         }
 919         break;
 920     case AV_CODEC_ID_ADPCM_AGM:
 921         for (i = 0; i < avctx->channels; i++)
 922             c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
 923         for (i = 0; i < avctx->channels; i++)
 924             c->status[i].step = sign_extend(bytestream2_get_le16u(&gb), 16);
 925
 926         for (n = 0; n < nb_samples >> (1 - st); n++) {
 927             int v = bytestream2_get_byteu(&gb);
 928             *samples++ = adpcm_agm_expand_nibble(&c->status[0], v & 0xF);
 929             *samples++ = adpcm_agm_expand_nibble(&c->status[st], v >> 4 );
 930         }
 931         break;
 932     case AV_CODEC_ID_ADPCM_MS:
 933     {
 934         int block_predictor;
 935
 936         if (avctx->channels > 2) {
 937             for (channel = 0; channel < avctx->channels; channel++) {
 938                 samples = samples_p[channel];
 939                 block_predictor = bytestream2_get_byteu(&gb);
 940                 if (block_predictor > 6) {
 941                     av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[%d] = %d\n",
 942                            channel, block_predictor);
 943                     return AVERROR_INVALIDDATA;
 944                 }
 945                 c->status[channel].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
 946                 c->status[channel].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
 947                 c->status[channel].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
 948                 c->status[channel].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
 949                 c->status[channel].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
 950                 *samples++ = c->status[channel].sample2;
 951                 *samples++ = c->status[channel].sample1;
 952                 for(n = (nb_samples - 2) >> 1; n > 0; n--) {
 953                     int byte = bytestream2_get_byteu(&gb);
 954                     *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte >> 4  );
 955                     *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte & 0x0F);
 956                 }
 957             }
 958         } else {
 959             block_predictor = bytestream2_get_byteu(&gb);
 960             if (block_predictor > 6) {
 961                 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
 962                        block_predictor);
 963                 return AVERROR_INVALIDDATA;
 964             }
 965             c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
 966             c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
 967             if (st) {
 968                 block_predictor = bytestream2_get_byteu(&gb);
 969                 if (block_predictor > 6) {
 970                     av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
 971                            block_predictor);
 972                     return AVERROR_INVALIDDATA;
 973                 }
 974                 c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
 975                 c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
 976             }
 977             c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
 978             if (st){
 979                 c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
 980             }
 981
 982             c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
 983             if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
 984             c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
 985             if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
 986
 987             *samples++ = c->status[0].sample2;
 988             if (st) *samples++ = c->status[1].sample2;
 989             *samples++ = c->status[0].sample1;
 990             if (st) *samples++ = c->status[1].sample1;
 991             for(n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
 992                 int byte = bytestream2_get_byteu(&gb);
 993                 *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4  );
 994                 *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
 995             }
 996         }
 997         break;
 998     }
 999     case AV_CODEC_ID_ADPCM_MTAF:
1000         for (channel = 0; channel < avctx->channels; channel+=2) {
1001             bytestream2_skipu(&gb, 4);
1002             c->status[channel    ].step      = bytestream2_get_le16u(&gb) & 0x1f;
1003             c->status[channel + 1].step      = bytestream2_get_le16u(&gb) & 0x1f;
1004             c->status[channel    ].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1005             bytestream2_skipu(&gb, 2);
1006             c->status[channel + 1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1007             bytestream2_skipu(&gb, 2);
1008             for (n = 0; n < nb_samples; n+=2) {
1009                 int v = bytestream2_get_byteu(&gb);
1010                 samples_p[channel][n    ] = adpcm_mtaf_expand_nibble(&c->status[channel], v & 0x0F);
1011                 samples_p[channel][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel], v >> 4  );
1012             }
1013             for (n = 0; n < nb_samples; n+=2) {
1014                 int v = bytestream2_get_byteu(&gb);
1015                 samples_p[channel + 1][n    ] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v & 0x0F);
1016                 samples_p[channel + 1][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v >> 4  );
1017             }
1018         }
1019         break;
1020     case AV_CODEC_ID_ADPCM_IMA_DK4:
1021         for (channel = 0; channel < avctx->channels; channel++) {
1022             cs = &c->status[channel];
1023             cs->predictor  = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
1024             cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1025             if (cs->step_index > 88u){
1026                 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1027                        channel, cs->step_index);
1028                 return AVERROR_INVALIDDATA;
1029             }
1030         }
1031         for (n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
1032             int v = bytestream2_get_byteu(&gb);
1033             *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4  , 3);
1034             *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1035         }
1036         break;
1037     case AV_CODEC_ID_ADPCM_IMA_DK3:
1038     {
1039         int last_byte = 0;
1040         int nibble;
1041         int decode_top_nibble_next = 0;
1042         int diff_channel;
1043         const int16_t *samples_end = samples + avctx->channels * nb_samples;
1044
1045         bytestream2_skipu(&gb, 10);
1046         c->status[0].predictor  = sign_extend(bytestream2_get_le16u(&gb), 16);
1047         c->status[1].predictor  = sign_extend(bytestream2_get_le16u(&gb), 16);
1048         c->status[0].step_index = bytestream2_get_byteu(&gb);
1049         c->status[1].step_index = bytestream2_get_byteu(&gb);
1050         if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
1051             av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
1052                    c->status[0].step_index, c->status[1].step_index);
1053             return AVERROR_INVALIDDATA;
1054         }
1055         /* sign extend the predictors */
1056         diff_channel = c->status[1].predictor;
1057
1058         /* DK3 ADPCM support macro */
1059 #define DK3_GET_NEXT_NIBBLE() \
1060     if (decode_top_nibble_next) { \
1061         nibble = last_byte >> 4; \
1062         decode_top_nibble_next = 0; \
1063     } else { \
1064         last_byte = bytestream2_get_byteu(&gb); \
1065         nibble = last_byte & 0x0F; \
1066         decode_top_nibble_next = 1; \
1067     }
1068
1069         while (samples < samples_end) {
1070
1071             /* for this algorithm, c->status[0] is the sum channel and
1072              * c->status[1] is the diff channel */
1073
1074             /* process the first predictor of the sum channel */
1075             DK3_GET_NEXT_NIBBLE();
1076             adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1077
1078             /* process the diff channel predictor */
1079             DK3_GET_NEXT_NIBBLE();
1080             adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
1081
1082             /* process the first pair of stereo PCM samples */
1083             diff_channel = (diff_channel + c->status[1].predictor) / 2;
1084             *samples++ = c->status[0].predictor + c->status[1].predictor;
1085             *samples++ = c->status[0].predictor - c->status[1].predictor;
1086
1087             /* process the second predictor of the sum channel */
1088             DK3_GET_NEXT_NIBBLE();
1089             adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1090
1091             /* process the second pair of stereo PCM samples */
1092             diff_channel = (diff_channel + c->status[1].predictor) / 2;
1093             *samples++ = c->status[0].predictor + c->status[1].predictor;
1094             *samples++ = c->status[0].predictor - c->status[1].predictor;
1095         }
1096
1097         if ((bytestream2_tell(&gb) & 1))
1098             bytestream2_skip(&gb, 1);
1099         break;
1100     }
1101     case AV_CODEC_ID_ADPCM_IMA_ISS:
1102         for (channel = 0; channel < avctx->channels; channel++) {
1103             cs = &c->status[channel];
1104             cs->predictor  = sign_extend(bytestream2_get_le16u(&gb), 16);
1105             cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1106             if (cs->step_index > 88u){
1107                 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1108                        channel, cs->step_index);
1109                 return AVERROR_INVALIDDATA;
1110             }
1111         }
1112
1113         for (n = nb_samples >> (1 - st); n > 0; n--) {
1114             int v1, v2;
1115             int v = bytestream2_get_byteu(&gb);
1116             /* nibbles are swapped for mono */
1117             if (st) {
1118                 v1 = v >> 4;
1119                 v2 = v & 0x0F;
1120             } else {
1121                 v2 = v >> 4;
1122                 v1 = v & 0x0F;
1123             }
1124             *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
1125             *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
1126         }
1127         break;
1128     case AV_CODEC_ID_ADPCM_IMA_DAT4:
1129         for (channel = 0; channel < avctx->channels; channel++) {
1130             cs = &c->status[channel];
1131             samples = samples_p[channel];
1132             bytestream2_skip(&gb, 4);
1133             for (n = 0; n < nb_samples; n += 2) {
1134                 int v = bytestream2_get_byteu(&gb);
1135                 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
1136                 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1137             }
1138         }
1139         break;
1140     case AV_CODEC_ID_ADPCM_IMA_APC:
1141         while (bytestream2_get_bytes_left(&gb) > 0) {
1142             int v = bytestream2_get_byteu(&gb);
1143             *samples++ = adpcm_ima_expand_nibble(&c->status[0],  v >> 4  , 3);
1144             *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1145         }
1146         break;
1147     case AV_CODEC_ID_ADPCM_IMA_OKI:
1148         while (bytestream2_get_bytes_left(&gb) > 0) {
1149             int v = bytestream2_get_byteu(&gb);
1150             *samples++ = adpcm_ima_oki_expand_nibble(&c->status[0],  v >> 4  );
1151             *samples++ = adpcm_ima_oki_expand_nibble(&c->status[st], v & 0x0F);
1152         }
1153         break;
1154     case AV_CODEC_ID_ADPCM_IMA_RAD:
1155         for (channel = 0; channel < avctx->channels; channel++) {
1156             cs = &c->status[channel];
1157             cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1158             cs->predictor  = sign_extend(bytestream2_get_le16u(&gb), 16);
1159             if (cs->step_index > 88u){
1160                 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1161                        channel, cs->step_index);
1162                 return AVERROR_INVALIDDATA;
1163             }
1164         }
1165         for (n = 0; n < nb_samples / 2; n++) {
1166             int byte[2];
1167
1168             byte[0] = bytestream2_get_byteu(&gb);
1169             if (st)
1170                 byte[1] = bytestream2_get_byteu(&gb);
1171             for(channel = 0; channel < avctx->channels; channel++) {
1172                 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] & 0x0F, 3);
1173             }
1174             for(channel = 0; channel < avctx->channels; channel++) {
1175                 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] >> 4  , 3);
1176             }
1177         }
1178         break;
1179     case AV_CODEC_ID_ADPCM_IMA_WS:
1180         if (c->vqa_version == 3) {
1181             for (channel = 0; channel < avctx->channels; channel++) {
1182                 int16_t *smp = samples_p[channel];
1183
1184                 for (n = nb_samples / 2; n > 0; n--) {
1185                     int v = bytestream2_get_byteu(&gb);
1186                     *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4  , 3);
1187                     *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1188                 }
1189             }
1190         } else {
1191             for (n = nb_samples / 2; n > 0; n--) {
1192                 for (channel = 0; channel < avctx->channels; channel++) {
1193                     int v = bytestream2_get_byteu(&gb);
1194                     *samples++  = adpcm_ima_expand_nibble(&c->status[channel], v >> 4  , 3);
1195                     samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1196                 }
1197                 samples += avctx->channels;
1198             }
1199         }
1200         bytestream2_seek(&gb, 0, SEEK_END);
1201         break;
1202     case AV_CODEC_ID_ADPCM_XA:
1203     {
1204         int16_t *out0 = samples_p[0];
1205         int16_t *out1 = samples_p[1];
1206         int samples_per_block = 28 * (3 - avctx->channels) * 4;
1207         int sample_offset = 0;
1208         int bytes_remaining;
1209         while (bytestream2_get_bytes_left(&gb) >= 128) {
1210             if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
1211                                  &c->status[0], &c->status[1],
1212                                  avctx->channels, sample_offset)) < 0)
1213                 return ret;
1214             bytestream2_skipu(&gb, 128);
1215             sample_offset += samples_per_block;
1216         }
1217         /* Less than a full block of data left, e.g. when reading from
1218          * 2324 byte per sector XA; the remainder is padding */
1219         bytes_remaining = bytestream2_get_bytes_left(&gb);
1220         if (bytes_remaining > 0) {
1221             bytestream2_skip(&gb, bytes_remaining);
1222         }
1223         break;
1224     }
1225     case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
1226         for (i=0; i<=st; i++) {
1227             c->status[i].step_index = bytestream2_get_le32u(&gb);
1228             if (c->status[i].step_index > 88u) {
1229                 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1230                        i, c->status[i].step_index);
1231                 return AVERROR_INVALIDDATA;
1232             }
1233         }
1234         for (i=0; i<=st; i++)
1235             c->status[i].predictor  = bytestream2_get_le32u(&gb);
1236
1237         for (n = nb_samples >> (1 - st); n > 0; n--) {
1238             int byte   = bytestream2_get_byteu(&gb);
1239             *samples++ = adpcm_ima_expand_nibble(&c->status[0],  byte >> 4,   3);
1240             *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
1241         }
1242         break;
1243     case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
1244         for (n = nb_samples >> (1 - st); n > 0; n--) {
1245             int byte = bytestream2_get_byteu(&gb);
1246             *samples++ = adpcm_ima_expand_nibble(&c->status[0],  byte >> 4,   6);
1247             *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
1248         }
1249         break;
1250     case AV_CODEC_ID_ADPCM_EA:
1251     {
1252         int previous_left_sample, previous_right_sample;
1253         int current_left_sample, current_right_sample;
1254         int next_left_sample, next_right_sample;
1255         int coeff1l, coeff2l, coeff1r, coeff2r;
1256         int shift_left, shift_right;
1257
1258         /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
1259            each coding 28 stereo samples. */
1260
1261         if(avctx->channels != 2)
1262             return AVERROR_INVALIDDATA;
1263
1264         current_left_sample   = sign_extend(bytestream2_get_le16u(&gb), 16);
1265         previous_left_sample  = sign_extend(bytestream2_get_le16u(&gb), 16);
1266         current_right_sample  = sign_extend(bytestream2_get_le16u(&gb), 16);
1267         previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1268
1269         for (count1 = 0; count1 < nb_samples / 28; count1++) {
1270             int byte = bytestream2_get_byteu(&gb);
1271             coeff1l = ea_adpcm_table[ byte >> 4       ];
1272             coeff2l = ea_adpcm_table[(byte >> 4  ) + 4];
1273             coeff1r = ea_adpcm_table[ byte & 0x0F];
1274             coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];
1275
1276             byte = bytestream2_get_byteu(&gb);
1277             shift_left  = 20 - (byte >> 4);
1278             shift_right = 20 - (byte & 0x0F);
1279
1280             for (count2 = 0; count2 < 28; count2++) {
1281                 byte = bytestream2_get_byteu(&gb);
1282                 next_left_sample  = sign_extend(byte >> 4, 4) << shift_left;
1283                 next_right_sample = sign_extend(byte,      4) << shift_right;
1284
1285                 next_left_sample = (next_left_sample +
1286                     (current_left_sample * coeff1l) +
1287                     (previous_left_sample * coeff2l) + 0x80) >> 8;
1288                 next_right_sample = (next_right_sample +
1289                     (current_right_sample * coeff1r) +
1290                     (previous_right_sample * coeff2r) + 0x80) >> 8;
1291
1292                 previous_left_sample = current_left_sample;
1293                 current_left_sample = av_clip_int16(next_left_sample);
1294                 previous_right_sample = current_right_sample;
1295                 current_right_sample = av_clip_int16(next_right_sample);
1296                 *samples++ = current_left_sample;
1297                 *samples++ = current_right_sample;
1298             }
1299         }
1300
1301         bytestream2_skip(&gb, 2); // Skip terminating 0x0000
1302
1303         break;
1304     }
1305     case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
1306     {
1307         int coeff[2][2], shift[2];
1308
1309         for(channel = 0; channel < avctx->channels; channel++) {
1310             int byte = bytestream2_get_byteu(&gb);
1311             for (i=0; i<2; i++)
1312                 coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
1313             shift[channel] = 20 - (byte & 0x0F);
1314         }
1315         for (count1 = 0; count1 < nb_samples / 2; count1++) {
1316             int byte[2];
1317
1318             byte[0] = bytestream2_get_byteu(&gb);
1319             if (st) byte[1] = bytestream2_get_byteu(&gb);
1320             for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
1321                 for(channel = 0; channel < avctx->channels; channel++) {
1322                     int sample = sign_extend(byte[channel] >> i, 4) << shift[channel];
1323                     sample = (sample +
1324                              c->status[channel].sample1 * coeff[channel][0] +
1325                              c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
1326                     c->status[channel].sample2 = c->status[channel].sample1;
1327                     c->status[channel].sample1 = av_clip_int16(sample);
1328                     *samples++ = c->status[channel].sample1;
1329                 }
1330             }
1331         }
1332         bytestream2_seek(&gb, 0, SEEK_END);
1333         break;
1334     }
1335     case AV_CODEC_ID_ADPCM_EA_R1:
1336     case AV_CODEC_ID_ADPCM_EA_R2:
1337     case AV_CODEC_ID_ADPCM_EA_R3: {
1338         /* channel numbering
1339            2chan: 0=fl, 1=fr
1340            4chan: 0=fl, 1=rl, 2=fr, 3=rr
1341            6chan: 0=fl, 1=c,  2=fr, 3=rl,  4=rr, 5=sub */
1342         const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1343         int previous_sample, current_sample, next_sample;
1344         int coeff1, coeff2;
1345         int shift;
1346         unsigned int channel;
1347         uint16_t *samplesC;
1348         int count = 0;
1349         int offsets[6];
1350
1351         for (channel=0; channel<avctx->channels; channel++)
1352             offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
1353                                              bytestream2_get_le32(&gb)) +
1354                                (avctx->channels + 1) * 4;
1355
1356         for (channel=0; channel<avctx->channels; channel++) {
1357             bytestream2_seek(&gb, offsets[channel], SEEK_SET);
1358             samplesC = samples_p[channel];
1359
1360             if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1361                 current_sample  = sign_extend(bytestream2_get_le16(&gb), 16);
1362                 previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1363             } else {
1364                 current_sample  = c->status[channel].predictor;
1365                 previous_sample = c->status[channel].prev_sample;
1366             }
1367
1368             for (count1 = 0; count1 < nb_samples / 28; count1++) {
1369                 int byte = bytestream2_get_byte(&gb);
1370                 if (byte == 0xEE) {  /* only seen in R2 and R3 */
1371                     current_sample  = sign_extend(bytestream2_get_be16(&gb), 16);
1372                     previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1373
1374                     for (count2=0; count2<28; count2++)
1375                         *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
1376                 } else {
1377                     coeff1 = ea_adpcm_table[ byte >> 4     ];
1378                     coeff2 = ea_adpcm_table[(byte >> 4) + 4];
1379                     shift = 20 - (byte & 0x0F);
1380
1381                     for (count2=0; count2<28; count2++) {
1382                         if (count2 & 1)
1383                             next_sample = sign_extend(byte,    4) << shift;
1384                         else {
1385                             byte = bytestream2_get_byte(&gb);
1386                             next_sample = sign_extend(byte >> 4, 4) << shift;
1387                         }
1388
1389                         next_sample += (current_sample  * coeff1) +
1390                                        (previous_sample * coeff2);
1391                         next_sample = av_clip_int16(next_sample >> 8);
1392
1393                         previous_sample = current_sample;
1394                         current_sample  = next_sample;
1395                         *samplesC++ = current_sample;
1396                     }
1397                 }
1398             }
1399             if (!count) {
1400                 count = count1;
1401             } else if (count != count1) {
1402                 av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
1403                 count = FFMAX(count, count1);
1404             }
1405
1406             if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1407                 c->status[channel].predictor   = current_sample;
1408                 c->status[channel].prev_sample = previous_sample;
1409             }
1410         }
1411
1412         frame->nb_samples = count * 28;
1413         bytestream2_seek(&gb, 0, SEEK_END);
1414         break;
1415     }
1416     case AV_CODEC_ID_ADPCM_EA_XAS:
1417         for (channel=0; channel<avctx->channels; channel++) {
1418             int coeff[2][4], shift[4];
1419             int16_t *s = samples_p[channel];
1420             for (n = 0; n < 4; n++, s += 32) {
1421                 int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1422                 for (i=0; i<2; i++)
1423                     coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];
1424                 s[0] = val & ~0x0F;
1425
1426                 val = sign_extend(bytestream2_get_le16u(&gb), 16);
1427                 shift[n] = 20 - (val & 0x0F);
1428                 s[1] = val & ~0x0F;
1429             }
1430
1431             for (m=2; m<32; m+=2) {
1432                 s = &samples_p[channel][m];
1433                 for (n = 0; n < 4; n++, s += 32) {
1434                     int level, pred;
1435                     int byte = bytestream2_get_byteu(&gb);
1436
1437                     level = sign_extend(byte >> 4, 4) << shift[n];
1438                     pred  = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
1439                     s[0]  = av_clip_int16((level + pred + 0x80) >> 8);
1440
1441                     level = sign_extend(byte, 4) << shift[n];
1442                     pred  = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
1443                     s[1]  = av_clip_int16((level + pred + 0x80) >> 8);
1444                 }
1445             }
1446         }
1447         break;
1448     case AV_CODEC_ID_ADPCM_IMA_AMV:
1449         c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1450         c->status[0].step_index = bytestream2_get_byteu(&gb);
1451         bytestream2_skipu(&gb, 5);
1452         if (c->status[0].step_index > 88u) {
1453             av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1454                    c->status[0].step_index);
1455             return AVERROR_INVALIDDATA;
1456         }
1457
1458         for (n = nb_samples >> (1 - st); n > 0; n--) {
1459             int v = bytestream2_get_byteu(&gb);
1460
1461             *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
1462             *samples++ = adpcm_ima_expand_nibble(&c->status[0], v & 0xf, 3);
1463         }
1464         break;
1465     case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
1466         for (i = 0; i < avctx->channels; i++) {
1467             c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
1468             c->status[i].step_index = bytestream2_get_byteu(&gb);
1469             bytestream2_skipu(&gb, 1);
1470             if (c->status[i].step_index > 88u) {
1471                 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1472                        c->status[i].step_index);
1473                 return AVERROR_INVALIDDATA;
1474             }
1475         }
1476
1477         for (n = nb_samples >> (1 - st); n > 0; n--) {
1478             int v = bytestream2_get_byteu(&gb);
1479
1480             *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4, 3);
1481             *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf, 3);
1482         }
1483         break;
1484     case AV_CODEC_ID_ADPCM_CT:
1485         for (n = nb_samples >> (1 - st); n > 0; n--) {
1486             int v = bytestream2_get_byteu(&gb);
1487             *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4  );
1488             *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1489         }
1490         break;
1491     case AV_CODEC_ID_ADPCM_SBPRO_4:
1492     case AV_CODEC_ID_ADPCM_SBPRO_3:
1493     case AV_CODEC_ID_ADPCM_SBPRO_2:
1494         if (!c->status[0].step_index) {
1495             /* the first byte is a raw sample */
1496             *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1497             if (st)
1498                 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1499             c->status[0].step_index = 1;
1500             nb_samples--;
1501         }
1502         if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1503             for (n = nb_samples >> (1 - st); n > 0; n--) {
1504                 int byte = bytestream2_get_byteu(&gb);
1505                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1506                                                        byte >> 4,   4, 0);
1507                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1508                                                        byte & 0x0F, 4, 0);
1509             }
1510         } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1511             for (n = (nb_samples<<st) / 3; n > 0; n--) {
1512                 int byte = bytestream2_get_byteu(&gb);
1513                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1514                                                         byte >> 5        , 3, 0);
1515                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1516                                                        (byte >> 2) & 0x07, 3, 0);
1517                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1518                                                         byte & 0x03,       2, 0);
1519             }
1520         } else {
1521             for (n = nb_samples >> (2 - st); n > 0; n--) {
1522                 int byte = bytestream2_get_byteu(&gb);
1523                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1524                                                         byte >> 6        , 2, 2);
1525                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1526                                                        (byte >> 4) & 0x03, 2, 2);
1527                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1528                                                        (byte >> 2) & 0x03, 2, 2);
1529                 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1530                                                         byte & 0x03,       2, 2);
1531             }
1532         }
1533         break;
1534     case AV_CODEC_ID_ADPCM_SWF:
1535         adpcm_swf_decode(avctx, buf, buf_size, samples);
1536         bytestream2_seek(&gb, 0, SEEK_END);
1537         break;
1538     case AV_CODEC_ID_ADPCM_YAMAHA:
1539         for (n = nb_samples >> (1 - st); n > 0; n--) {
1540             int v = bytestream2_get_byteu(&gb);
1541             *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
1542             *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4  );
1543         }
1544         break;
1545     case AV_CODEC_ID_ADPCM_AICA:
1546         if (!c->has_status) {
1547             for (channel = 0; channel < avctx->channels; channel++)
1548                 c->status[channel].step = 0;
1549             c->has_status = 1;
1550         }
1551         for (channel = 0; channel < avctx->channels; channel++) {
1552             samples = samples_p[channel];
1553             for (n = nb_samples >> 1; n > 0; n--) {
1554                 int v = bytestream2_get_byteu(&gb);
1555                 *samples++ = adpcm_yamaha_expand_nibble(&c->status[channel], v & 0x0F);
1556                 *samples++ = adpcm_yamaha_expand_nibble(&c->status[channel], v >> 4  );
1557             }
1558         }
1559         break;
1560     case AV_CODEC_ID_ADPCM_AFC:
1561     {
1562         int samples_per_block;
1563         int blocks;
1564
1565         if (avctx->extradata && avctx->extradata_size == 1 && avctx->extradata[0]) {
1566             samples_per_block = avctx->extradata[0] / 16;
1567             blocks = nb_samples / avctx->extradata[0];
1568         } else {
1569             samples_per_block = nb_samples / 16;
1570             blocks = 1;
1571         }
1572
1573         for (m = 0; m < blocks; m++) {
1574         for (channel = 0; channel < avctx->channels; channel++) {
1575             int prev1 = c->status[channel].sample1;
1576             int prev2 = c->status[channel].sample2;
1577
1578             samples = samples_p[channel] + m * 16;
1579             /* Read in every sample for this channel.  */
1580             for (i = 0; i < samples_per_block; i++) {
1581                 int byte = bytestream2_get_byteu(&gb);
1582                 int scale = 1 << (byte >> 4);
1583                 int index = byte & 0xf;
1584                 int factor1 = ff_adpcm_afc_coeffs[0][index];
1585                 int factor2 = ff_adpcm_afc_coeffs[1][index];
1586
1587                 /* Decode 16 samples.  */
1588                 for (n = 0; n < 16; n++) {
1589                     int32_t sampledat;
1590
1591                     if (n & 1) {
1592                         sampledat = sign_extend(byte, 4);
1593                     } else {
1594                         byte = bytestream2_get_byteu(&gb);
1595                         sampledat = sign_extend(byte >> 4, 4);
1596                     }
1597
1598                     sampledat = ((prev1 * factor1 + prev2 * factor2) +
1599                                  ((sampledat * scale) << 11)) >> 11;
1600                     *samples = av_clip_int16(sampledat);
1601                     prev2 = prev1;
1602                     prev1 = *samples++;
1603                 }
1604             }
1605
1606             c->status[channel].sample1 = prev1;
1607             c->status[channel].sample2 = prev2;
1608         }
1609         }
1610         bytestream2_seek(&gb, 0, SEEK_END);
1611         break;
1612     }
1613     case AV_CODEC_ID_ADPCM_THP:
1614     case AV_CODEC_ID_ADPCM_THP_LE:
1615     {
1616         int table[14][16];
1617         int ch;
1618
1619 #define THP_GET16(g) \
1620     sign_extend( \
1621         avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE ? \
1622         bytestream2_get_le16u(&(g)) : \
1623         bytestream2_get_be16u(&(g)), 16)
1624
1625         if (avctx->extradata) {
1626             GetByteContext tb;
1627             if (avctx->extradata_size < 32 * avctx->channels) {
1628                 av_log(avctx, AV_LOG_ERROR, "Missing coeff table\n");
1629                 return AVERROR_INVALIDDATA;
1630             }
1631
1632             bytestream2_init(&tb, avctx->extradata, avctx->extradata_size);
1633             for (i = 0; i < avctx->channels; i++)
1634                 for (n = 0; n < 16; n++)
1635                     table[i][n] = THP_GET16(tb);
1636         } else {
1637             for (i = 0; i < avctx->channels; i++)
1638                 for (n = 0; n < 16; n++)
1639                     table[i][n] = THP_GET16(gb);
1640
1641             if (!c->has_status) {
1642                 /* Initialize the previous sample.  */
1643                 for (i = 0; i < avctx->channels; i++) {
1644                     c->status[i].sample1 = THP_GET16(gb);
1645                     c->status[i].sample2 = THP_GET16(gb);
1646                 }
1647                 c->has_status = 1;
1648             } else {
1649                 bytestream2_skip(&gb, avctx->channels * 4);
1650             }
1651         }
1652
1653         for (ch = 0; ch < avctx->channels; ch++) {
1654             samples = samples_p[ch];
1655
1656             /* Read in every sample for this channel.  */
1657             for (i = 0; i < (nb_samples + 13) / 14; i++) {
1658                 int byte = bytestream2_get_byteu(&gb);
1659                 int index = (byte >> 4) & 7;
1660                 unsigned int exp = byte & 0x0F;
1661                 int factor1 = table[ch][index * 2];
1662                 int factor2 = table[ch][index * 2 + 1];
1663
1664                 /* Decode 14 samples.  */
1665                 for (n = 0; n < 14 && (i * 14 + n < nb_samples); n++) {
1666                     int32_t sampledat;
1667
1668                     if (n & 1) {
1669                         sampledat = sign_extend(byte, 4);
1670                     } else {
1671                         byte = bytestream2_get_byteu(&gb);
1672                         sampledat = sign_extend(byte >> 4, 4);
1673                     }
1674
1675                     sampledat = ((c->status[ch].sample1 * factor1
1676                                 + c->status[ch].sample2 * factor2) >> 11) + (sampledat << exp);
1677                     *samples = av_clip_int16(sampledat);
1678                     c->status[ch].sample2 = c->status[ch].sample1;
1679                     c->status[ch].sample1 = *samples++;
1680                 }
1681             }
1682         }
1683         break;
1684     }
1685     case AV_CODEC_ID_ADPCM_DTK:
1686         for (channel = 0; channel < avctx->channels; channel++) {
1687             samples = samples_p[channel];
1688
1689             /* Read in every sample for this channel.  */
1690             for (i = 0; i < nb_samples / 28; i++) {
1691                 int byte, header;
1692                 if (channel)
1693                     bytestream2_skipu(&gb, 1);
1694                 header = bytestream2_get_byteu(&gb);
1695                 bytestream2_skipu(&gb, 3 - channel);
1696
1697                 /* Decode 28 samples.  */
1698                 for (n = 0; n < 28; n++) {
1699                     int32_t sampledat, prev;
1700
1701                     switch (header >> 4) {
1702                     case 1:
1703                         prev = (c->status[channel].sample1 * 0x3c);
1704                         break;
1705                     case 2:
1706                         prev = (c->status[channel].sample1 * 0x73) - (c->status[channel].sample2 * 0x34);
1707                         break;
1708                     case 3:
1709                         prev = (c->status[channel].sample1 * 0x62) - (c->status[channel].sample2 * 0x37);
1710                         break;
1711                     default:
1712                         prev = 0;
1713                     }
1714
1715                     prev = av_clip_intp2((prev + 0x20) >> 6, 21);
1716
1717                     byte = bytestream2_get_byteu(&gb);
1718                     if (!channel)
1719                         sampledat = sign_extend(byte, 4);
1720                     else
1721                         sampledat = sign_extend(byte >> 4, 4);
1722
1723                     sampledat = (((sampledat << 12) >> (header & 0xf)) << 6) + prev;
1724                     *samples++ = av_clip_int16(sampledat >> 6);
1725                     c->status[channel].sample2 = c->status[channel].sample1;
1726                     c->status[channel].sample1 = sampledat;
1727                 }
1728             }
1729             if (!channel)
1730                 bytestream2_seek(&gb, 0, SEEK_SET);
1731         }
1732         break;
1733     case AV_CODEC_ID_ADPCM_PSX:
1734         for (channel = 0; channel < avctx->channels; channel++) {
1735             samples = samples_p[channel];
1736
1737             /* Read in every sample for this channel.  */
1738             for (i = 0; i < nb_samples / 28; i++) {
1739                 int filter, shift, flag, byte;
1740
1741                 filter = bytestream2_get_byteu(&gb);
1742                 shift  = filter & 0xf;
1743                 filter = filter >> 4;
1744                 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table))
1745                     return AVERROR_INVALIDDATA;
1746                 flag   = bytestream2_get_byteu(&gb);
1747
1748                 /* Decode 28 samples.  */
1749                 for (n = 0; n < 28; n++) {
1750                     int sample = 0, scale;
1751
1752                     if (flag < 0x07) {
1753                         if (n & 1) {
1754                             scale = sign_extend(byte >> 4, 4);
1755                         } else {
1756                             byte  = bytestream2_get_byteu(&gb);
1757                             scale = sign_extend(byte, 4);
1758                         }
1759
1760                         scale  = scale << 12;
1761                         sample = (int)((scale >> shift) + (c->status[channel].sample1 * xa_adpcm_table[filter][0] + c->status[channel].sample2 * xa_adpcm_table[filter][1]) / 64);
1762                     }
1763                     *samples++ = av_clip_int16(sample);
1764                     c->status[channel].sample2 = c->status[channel].sample1;
1765                     c->status[channel].sample1 = sample;
1766                 }
1767             }
1768         }
1769         break;
1770
1771     default:
1772         av_assert0(0); // unsupported codec_id should not happen
1773     }
1774
1775     if (avpkt->size && bytestream2_tell(&gb) == 0) {
1776         av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n");
1777         return AVERROR_INVALIDDATA;
1778     }
1779
1780     *got_frame_ptr = 1;
1781
1782     if (avpkt->size < bytestream2_tell(&gb)) {
1783         av_log(avctx, AV_LOG_ERROR, "Overread of %d < %d\n", avpkt->size, bytestream2_tell(&gb));
1784         return avpkt->size;
1785     }
1786
1787     return bytestream2_tell(&gb);
1788 }
1789
1790 static void adpcm_flush(AVCodecContext *avctx)
1791 {
1792     ADPCMDecodeContext *c = avctx->priv_data;
1793     c->has_status = 0;
1794 }
1795
1796
1797 static const enum AVSampleFormat sample_fmts_s16[]  = { AV_SAMPLE_FMT_S16,
1798                                                         AV_SAMPLE_FMT_NONE };
1799 static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16P,
1800                                                         AV_SAMPLE_FMT_NONE };
1801 static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16,
1802                                                         AV_SAMPLE_FMT_S16P,
1803                                                         AV_SAMPLE_FMT_NONE };
1804
1805 #define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \
1806 AVCodec ff_ ## name_ ## _decoder = {                        \
1807     .name           = #name_,                               \
1808     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
1809     .type           = AVMEDIA_TYPE_AUDIO,                   \
1810     .id             = id_,                                  \
1811     .priv_data_size = sizeof(ADPCMDecodeContext),           \
1812     .init           = adpcm_decode_init,                    \
1813     .decode         = adpcm_decode_frame,                   \
1814     .flush          = adpcm_flush,                          \
1815     .capabilities   = AV_CODEC_CAP_DR1,                     \
1816     .sample_fmts    = sample_fmts_,                         \
1817 }
1818
1819 /* Note: Do not forget to add new entries to the Makefile as well. */
1820 ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM,         sample_fmts_s16p, adpcm_4xm,         "ADPCM 4X Movie");
1821 ADPCM_DECODER(AV_CODEC_ID_ADPCM_AFC,         sample_fmts_s16p, adpcm_afc,         "ADPCM Nintendo Gamecube AFC");
1822 ADPCM_DECODER(AV_CODEC_ID_ADPCM_AGM,         sample_fmts_s16,  adpcm_agm,         "ADPCM AmuseGraphics Movie");
1823 ADPCM_DECODER(AV_CODEC_ID_ADPCM_AICA,        sample_fmts_s16p, adpcm_aica,        "ADPCM Yamaha AICA");
1824 ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT,          sample_fmts_s16,  adpcm_ct,          "ADPCM Creative Technology");
1825 ADPCM_DECODER(AV_CODEC_ID_ADPCM_DTK,         sample_fmts_s16p, adpcm_dtk,         "ADPCM Nintendo Gamecube DTK");
1826 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA,          sample_fmts_s16,  adpcm_ea,          "ADPCM Electronic Arts");
1827 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_MAXIS_XA, sample_fmts_s16,  adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
1828 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1,       sample_fmts_s16p, adpcm_ea_r1,       "ADPCM Electronic Arts R1");
1829 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R2,       sample_fmts_s16p, adpcm_ea_r2,       "ADPCM Electronic Arts R2");
1830 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R3,       sample_fmts_s16p, adpcm_ea_r3,       "ADPCM Electronic Arts R3");
1831 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS,      sample_fmts_s16p, adpcm_ea_xas,      "ADPCM Electronic Arts XAS");
1832 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_AMV,     sample_fmts_s16,  adpcm_ima_amv,     "ADPCM IMA AMV");
1833 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APC,     sample_fmts_s16,  adpcm_ima_apc,     "ADPCM IMA CRYO APC");
1834 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DAT4,    sample_fmts_s16,  adpcm_ima_dat4,    "ADPCM IMA Eurocom DAT4");
1835 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK3,     sample_fmts_s16,  adpcm_ima_dk3,     "ADPCM IMA Duck DK3");
1836 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4,     sample_fmts_s16,  adpcm_ima_dk4,     "ADPCM IMA Duck DK4");
1837 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_EACS, sample_fmts_s16,  adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
1838 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_SEAD, sample_fmts_s16,  adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
1839 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ISS,     sample_fmts_s16,  adpcm_ima_iss,     "ADPCM IMA Funcom ISS");
1840 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_OKI,     sample_fmts_s16,  adpcm_ima_oki,     "ADPCM IMA Dialogic OKI");
1841 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT,      sample_fmts_s16p, adpcm_ima_qt,      "ADPCM IMA QuickTime");
1842 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_RAD,     sample_fmts_s16,  adpcm_ima_rad,     "ADPCM IMA Radical");
1843 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG,  sample_fmts_s16,  adpcm_ima_smjpeg,  "ADPCM IMA Loki SDL MJPEG");
1844 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV,     sample_fmts_s16p, adpcm_ima_wav,     "ADPCM IMA WAV");
1845 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS,      sample_fmts_both, adpcm_ima_ws,      "ADPCM IMA Westwood");
1846 ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS,          sample_fmts_both, adpcm_ms,          "ADPCM Microsoft");
1847 ADPCM_DECODER(AV_CODEC_ID_ADPCM_MTAF,        sample_fmts_s16p, adpcm_mtaf,        "ADPCM MTAF");
1848 ADPCM_DECODER(AV_CODEC_ID_ADPCM_PSX,         sample_fmts_s16p, adpcm_psx,         "ADPCM Playstation");
1849 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2,     sample_fmts_s16,  adpcm_sbpro_2,     "ADPCM Sound Blaster Pro 2-bit");
1850 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_3,     sample_fmts_s16,  adpcm_sbpro_3,     "ADPCM Sound Blaster Pro 2.6-bit");
1851 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_4,     sample_fmts_s16,  adpcm_sbpro_4,     "ADPCM Sound Blaster Pro 4-bit");
1852 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SWF,         sample_fmts_s16,  adpcm_swf,         "ADPCM Shockwave Flash");
1853 ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP_LE,      sample_fmts_s16p, adpcm_thp_le,      "ADPCM Nintendo THP (little-endian)");
1854 ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP,         sample_fmts_s16p, adpcm_thp,         "ADPCM Nintendo THP");
1855 ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA,          sample_fmts_s16p, adpcm_xa,          "ADPCM CDROM XA");
1856 ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA,      sample_fmts_s16,  adpcm_yamaha,      "ADPCM Yamaha");