← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gst-libav1.0/trusty-proposed

« back to all changes in this revision

Viewing changes to gst-libs/ext/libav/libavcodec/adpcm.c

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2013-09-24 17:07:00 UTC
  • mfrom: (1.1.17) (7.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20130924170700-4dg62s3pwl0pdakz
Tags: 1.2.0-1
* New upstream stable release:
  + debian/control:
    - Build depend on GStreamer and gst-plugins-base >= 1.2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/libav/libavcodec/adpcm.c
23
23
#include "bytestream.h"
24
24
#include "adpcm.h"
25
25
#include "adpcm_data.h"
 
26
#include "internal.h"
26
27
 
27
28
/**
28
29
 * @file
86
87
typedef struct ADPCMDecodeContext {
87
88
    AVFrame frame;
88
89
    ADPCMChannelStatus status[6];
 
90
    int vqa_version;                /**< VQA version. Used for ADPCM_IMA_WS */
89
91
} ADPCMDecodeContext;
90
92
 
91
93
static av_cold int adpcm_decode_init(AVCodecContext * avctx)
95
97
    unsigned int max_channels = 2;
96
98
 
97
99
    switch(avctx->codec->id) {
98
 
    case CODEC_ID_ADPCM_EA:
 
100
    case AV_CODEC_ID_ADPCM_EA:
99
101
        min_channels = 2;
100
102
        break;
101
 
    case CODEC_ID_ADPCM_EA_R1:
102
 
    case CODEC_ID_ADPCM_EA_R2:
103
 
    case CODEC_ID_ADPCM_EA_R3:
104
 
    case CODEC_ID_ADPCM_EA_XAS:
 
103
    case AV_CODEC_ID_ADPCM_EA_R1:
 
104
    case AV_CODEC_ID_ADPCM_EA_R2:
 
105
    case AV_CODEC_ID_ADPCM_EA_R3:
 
106
    case AV_CODEC_ID_ADPCM_EA_XAS:
105
107
        max_channels = 6;
106
108
        break;
107
109
    }
111
113
    }
112
114
 
113
115
    switch(avctx->codec->id) {
114
 
    case CODEC_ID_ADPCM_CT:
 
116
    case AV_CODEC_ID_ADPCM_CT:
115
117
        c->status[0].step = c->status[1].step = 511;
116
118
        break;
117
 
    case CODEC_ID_ADPCM_IMA_WAV:
 
119
    case AV_CODEC_ID_ADPCM_IMA_WAV:
118
120
        if (avctx->bits_per_coded_sample != 4) {
119
121
            av_log(avctx, AV_LOG_ERROR, "Only 4-bit ADPCM IMA WAV files are supported\n");
120
122
            return -1;
121
123
        }
122
124
        break;
123
 
    case CODEC_ID_ADPCM_IMA_WS:
124
 
        if (avctx->extradata && avctx->extradata_size == 2 * 4) {
 
125
    case AV_CODEC_ID_ADPCM_IMA_APC:
 
126
        if (avctx->extradata && avctx->extradata_size >= 8) {
125
127
            c->status[0].predictor = AV_RL32(avctx->extradata);
126
128
            c->status[1].predictor = AV_RL32(avctx->extradata + 4);
127
129
        }
128
130
        break;
 
131
    case AV_CODEC_ID_ADPCM_IMA_WS:
 
132
        if (avctx->extradata && avctx->extradata_size >= 2)
 
133
            c->vqa_version = AV_RL16(avctx->extradata);
 
134
        break;
129
135
    default:
130
136
        break;
131
137
    }
132
 
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 
138
 
 
139
    switch(avctx->codec->id) {
 
140
        case AV_CODEC_ID_ADPCM_IMA_QT:
 
141
        case AV_CODEC_ID_ADPCM_IMA_WAV:
 
142
        case AV_CODEC_ID_ADPCM_4XM:
 
143
        case AV_CODEC_ID_ADPCM_XA:
 
144
        case AV_CODEC_ID_ADPCM_EA_R1:
 
145
        case AV_CODEC_ID_ADPCM_EA_R2:
 
146
        case AV_CODEC_ID_ADPCM_EA_R3:
 
147
        case AV_CODEC_ID_ADPCM_EA_XAS:
 
148
        case AV_CODEC_ID_ADPCM_THP:
 
149
            avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
 
150
            break;
 
151
        case AV_CODEC_ID_ADPCM_IMA_WS:
 
152
            avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
 
153
                                                      AV_SAMPLE_FMT_S16;
 
154
            break;
 
155
        default:
 
156
            avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 
157
    }
133
158
 
134
159
    avcodec_get_frame_defaults(&c->frame);
135
160
    avctx->coded_frame = &c->frame;
145
170
 
146
171
    step = ff_adpcm_step_table[c->step_index];
147
172
    step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
148
 
    if (step_index < 0) step_index = 0;
149
 
    else if (step_index > 88) step_index = 88;
 
173
    step_index = av_clip(step_index, 0, 88);
150
174
 
151
175
    sign = nibble & 8;
152
176
    delta = nibble & 7;
190
214
    return c->predictor;
191
215
}
192
216
 
193
 
static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
 
217
static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
194
218
{
195
219
    int predictor;
196
220
 
197
221
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
198
 
    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
 
222
    predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
199
223
 
200
224
    c->sample2 = c->sample1;
201
225
    c->sample1 = av_clip_int16(predictor);
260
284
    return c->predictor;
261
285
}
262
286
 
263
 
static int xa_decode(AVCodecContext *avctx,
264
 
                     short *out, const unsigned char *in,
265
 
                     ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
 
287
static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
 
288
                     const uint8_t *in, ADPCMChannelStatus *left,
 
289
                     ADPCMChannelStatus *right, int channels, int sample_offset)
266
290
{
267
291
    int i, j;
268
292
    int shift,filter,f0,f1;
269
293
    int s_1,s_2;
270
294
    int d,s,t;
271
295
 
 
296
    out0 += sample_offset;
 
297
    if (channels == 1)
 
298
        out1 = out0 + 28;
 
299
    else
 
300
        out1 += sample_offset;
 
301
 
272
302
    for(i=0;i<4;i++) {
273
 
 
274
303
        shift  = 12 - (in[4+i*2] & 15);
275
304
        filter = in[4+i*2] >> 4;
276
305
        if (filter > 4) {
288
317
        for(j=0;j<28;j++) {
289
318
            d = in[16+i+j*4];
290
319
 
291
 
            t = (signed char)(d<<4)>>4;
 
320
            t = sign_extend(d, 4);
292
321
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
293
322
            s_2 = s_1;
294
323
            s_1 = av_clip_int16(s);
295
 
            *out = s_1;
296
 
            out += inc;
 
324
            out0[j] = s_1;
297
325
        }
298
326
 
299
 
        if (inc==2) { /* stereo */
 
327
        if (channels == 2) {
300
328
            left->sample1 = s_1;
301
329
            left->sample2 = s_2;
302
330
            s_1 = right->sample1;
303
331
            s_2 = right->sample2;
304
 
            out = out + 1 - 28*2;
305
332
        }
306
333
 
307
334
        shift  = 12 - (in[5+i*2] & 15);
318
345
        for(j=0;j<28;j++) {
319
346
            d = in[16+i+j*4];
320
347
 
321
 
            t = (signed char)d >> 4;
 
348
            t = sign_extend(d >> 4, 4);
322
349
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
323
350
            s_2 = s_1;
324
351
            s_1 = av_clip_int16(s);
325
 
            *out = s_1;
326
 
            out += inc;
 
352
            out1[j] = s_1;
327
353
        }
328
354
 
329
 
        if (inc==2) { /* stereo */
 
355
        if (channels == 2) {
330
356
            right->sample1 = s_1;
331
357
            right->sample2 = s_2;
332
 
            out -= 1;
333
358
        } else {
334
359
            left->sample1 = s_1;
335
360
            left->sample2 = s_2;
336
361
        }
 
362
 
 
363
        out0 += 28 * (3 - channels);
 
364
        out1 += 28 * (3 - channels);
337
365
    }
338
366
 
339
367
    return 0;
340
368
}
341
369
 
 
370
static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
 
371
{
 
372
    ADPCMDecodeContext *c = avctx->priv_data;
 
373
    GetBitContext gb;
 
374
    const int *table;
 
375
    int k0, signmask, nb_bits, count;
 
376
    int size = buf_size*8;
 
377
    int i;
 
378
 
 
379
    init_get_bits(&gb, buf, size);
 
380
 
 
381
    //read bits & initial values
 
382
    nb_bits = get_bits(&gb, 2)+2;
 
383
    table = swf_index_tables[nb_bits-2];
 
384
    k0 = 1 << (nb_bits-2);
 
385
    signmask = 1 << (nb_bits-1);
 
386
 
 
387
    while (get_bits_count(&gb) <= size - 22*avctx->channels) {
 
388
        for (i = 0; i < avctx->channels; i++) {
 
389
            *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
 
390
            c->status[i].step_index = get_bits(&gb, 6);
 
391
        }
 
392
 
 
393
        for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
 
394
            int i;
 
395
 
 
396
            for (i = 0; i < avctx->channels; i++) {
 
397
                // similar to IMA adpcm
 
398
                int delta = get_bits(&gb, nb_bits);
 
399
                int step = ff_adpcm_step_table[c->status[i].step_index];
 
400
                long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
 
401
                int k = k0;
 
402
 
 
403
                do {
 
404
                    if (delta & k)
 
405
                        vpdiff += step;
 
406
                    step >>= 1;
 
407
                    k >>= 1;
 
408
                } while(k);
 
409
                vpdiff += step;
 
410
 
 
411
                if (delta & signmask)
 
412
                    c->status[i].predictor -= vpdiff;
 
413
                else
 
414
                    c->status[i].predictor += vpdiff;
 
415
 
 
416
                c->status[i].step_index += table[delta & (~signmask)];
 
417
 
 
418
                c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
 
419
                c->status[i].predictor = av_clip_int16(c->status[i].predictor);
 
420
 
 
421
                *samples++ = c->status[i].predictor;
 
422
            }
 
423
        }
 
424
    }
 
425
}
 
426
 
342
427
/**
343
428
 * Get the number of samples that will be decoded from the packet.
344
429
 * In one case, this is actually the maximum number of samples possible to
348
433
 *                           packet, or 0 if the codec does not encode the
349
434
 *                           number of samples in each frame.
350
435
 */
351
 
static int get_nb_samples(AVCodecContext *avctx, const uint8_t *buf,
 
436
static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
352
437
                          int buf_size, int *coded_samples)
353
438
{
354
439
    ADPCMDecodeContext *s = avctx->priv_data;
361
446
 
362
447
    switch (avctx->codec->id) {
363
448
    /* constant, only check buf_size */
364
 
    case CODEC_ID_ADPCM_EA_XAS:
 
449
    case AV_CODEC_ID_ADPCM_EA_XAS:
365
450
        if (buf_size < 76 * ch)
366
451
            return 0;
367
452
        nb_samples = 128;
368
453
        break;
369
 
    case CODEC_ID_ADPCM_IMA_QT:
 
454
    case AV_CODEC_ID_ADPCM_IMA_QT:
370
455
        if (buf_size < 34 * ch)
371
456
            return 0;
372
457
        nb_samples = 64;
373
458
        break;
374
459
    /* simple 4-bit adpcm */
375
 
    case CODEC_ID_ADPCM_CT:
376
 
    case CODEC_ID_ADPCM_IMA_EA_SEAD:
377
 
    case CODEC_ID_ADPCM_IMA_WS:
378
 
    case CODEC_ID_ADPCM_YAMAHA:
 
460
    case AV_CODEC_ID_ADPCM_CT:
 
461
    case AV_CODEC_ID_ADPCM_IMA_APC:
 
462
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
 
463
    case AV_CODEC_ID_ADPCM_IMA_WS:
 
464
    case AV_CODEC_ID_ADPCM_YAMAHA:
379
465
        nb_samples = buf_size * 2 / ch;
380
466
        break;
381
467
    }
385
471
    /* simple 4-bit adpcm, with header */
386
472
    header_size = 0;
387
473
    switch (avctx->codec->id) {
388
 
        case CODEC_ID_ADPCM_4XM:
389
 
        case CODEC_ID_ADPCM_IMA_ISS:     header_size = 4 * ch;      break;
390
 
        case CODEC_ID_ADPCM_IMA_AMV:     header_size = 8;           break;
391
 
        case CODEC_ID_ADPCM_IMA_SMJPEG:  header_size = 4;           break;
 
474
        case AV_CODEC_ID_ADPCM_4XM:
 
475
        case AV_CODEC_ID_ADPCM_IMA_ISS:     header_size = 4 * ch;      break;
 
476
        case AV_CODEC_ID_ADPCM_IMA_AMV:     header_size = 8;           break;
 
477
        case AV_CODEC_ID_ADPCM_IMA_SMJPEG:  header_size = 4;           break;
392
478
    }
393
479
    if (header_size > 0)
394
480
        return (buf_size - header_size) * 2 / ch;
395
481
 
396
482
    /* more complex formats */
397
483
    switch (avctx->codec->id) {
398
 
    case CODEC_ID_ADPCM_EA:
 
484
    case AV_CODEC_ID_ADPCM_EA:
399
485
        has_coded_samples = 1;
400
 
        if (buf_size < 4)
401
 
            return 0;
402
 
        *coded_samples  = AV_RL32(buf);
 
486
        *coded_samples  = bytestream2_get_le32(gb);
403
487
        *coded_samples -= *coded_samples % 28;
404
488
        nb_samples      = (buf_size - 12) / 30 * 28;
405
489
        break;
406
 
    case CODEC_ID_ADPCM_IMA_EA_EACS:
 
490
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
407
491
        has_coded_samples = 1;
408
 
        if (buf_size < 4)
409
 
            return 0;
410
 
        *coded_samples = AV_RL32(buf);
 
492
        *coded_samples = bytestream2_get_le32(gb);
411
493
        nb_samples     = (buf_size - (4 + 8 * ch)) * 2 / ch;
412
494
        break;
413
 
    case CODEC_ID_ADPCM_EA_MAXIS_XA:
414
 
        nb_samples = ((buf_size - ch) / (2 * ch)) * 2 * ch;
 
495
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
 
496
        nb_samples = (buf_size - ch) / ch * 2;
415
497
        break;
416
 
    case CODEC_ID_ADPCM_EA_R1:
417
 
    case CODEC_ID_ADPCM_EA_R2:
418
 
    case CODEC_ID_ADPCM_EA_R3:
 
498
    case AV_CODEC_ID_ADPCM_EA_R1:
 
499
    case AV_CODEC_ID_ADPCM_EA_R2:
 
500
    case AV_CODEC_ID_ADPCM_EA_R3:
419
501
        /* maximum number of samples */
420
502
        /* has internal offsets and a per-frame switch to signal raw 16-bit */
421
503
        has_coded_samples = 1;
422
 
        if (buf_size < 4)
423
 
            return 0;
424
504
        switch (avctx->codec->id) {
425
 
        case CODEC_ID_ADPCM_EA_R1:
 
505
        case AV_CODEC_ID_ADPCM_EA_R1:
426
506
            header_size    = 4 + 9 * ch;
427
 
            *coded_samples = AV_RL32(buf);
428
 
            break;
429
 
        case CODEC_ID_ADPCM_EA_R2:
430
 
            header_size    = 4 + 5 * ch;
431
 
            *coded_samples = AV_RL32(buf);
432
 
            break;
433
 
        case CODEC_ID_ADPCM_EA_R3:
434
 
            header_size    = 4 + 5 * ch;
435
 
            *coded_samples = AV_RB32(buf);
 
507
            *coded_samples = bytestream2_get_le32(gb);
 
508
            break;
 
509
        case AV_CODEC_ID_ADPCM_EA_R2:
 
510
            header_size    = 4 + 5 * ch;
 
511
            *coded_samples = bytestream2_get_le32(gb);
 
512
            break;
 
513
        case AV_CODEC_ID_ADPCM_EA_R3:
 
514
            header_size    = 4 + 5 * ch;
 
515
            *coded_samples = bytestream2_get_be32(gb);
436
516
            break;
437
517
        }
438
518
        *coded_samples -= *coded_samples % 28;
439
519
        nb_samples      = (buf_size - header_size) * 2 / ch;
440
520
        nb_samples     -= nb_samples % 28;
441
521
        break;
442
 
    case CODEC_ID_ADPCM_IMA_DK3:
 
522
    case AV_CODEC_ID_ADPCM_IMA_DK3:
443
523
        if (avctx->block_align > 0)
444
524
            buf_size = FFMIN(buf_size, avctx->block_align);
445
 
        nb_samples = ((buf_size - 16) * 8 / 3) / ch;
 
525
        nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
446
526
        break;
447
 
    case CODEC_ID_ADPCM_IMA_DK4:
 
527
    case AV_CODEC_ID_ADPCM_IMA_DK4:
 
528
        if (avctx->block_align > 0)
 
529
            buf_size = FFMIN(buf_size, avctx->block_align);
448
530
        nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
449
531
        break;
450
 
    case CODEC_ID_ADPCM_IMA_WAV:
 
532
    case AV_CODEC_ID_ADPCM_IMA_WAV:
451
533
        if (avctx->block_align > 0)
452
534
            buf_size = FFMIN(buf_size, avctx->block_align);
453
535
        nb_samples = 1 + (buf_size - 4 * ch) / (4 * ch) * 8;
454
536
        break;
455
 
    case CODEC_ID_ADPCM_MS:
 
537
    case AV_CODEC_ID_ADPCM_MS:
456
538
        if (avctx->block_align > 0)
457
539
            buf_size = FFMIN(buf_size, avctx->block_align);
458
540
        nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;
459
541
        break;
460
 
    case CODEC_ID_ADPCM_SBPRO_2:
461
 
    case CODEC_ID_ADPCM_SBPRO_3:
462
 
    case CODEC_ID_ADPCM_SBPRO_4:
 
542
    case AV_CODEC_ID_ADPCM_SBPRO_2:
 
543
    case AV_CODEC_ID_ADPCM_SBPRO_3:
 
544
    case AV_CODEC_ID_ADPCM_SBPRO_4:
463
545
    {
464
546
        int samples_per_byte;
465
547
        switch (avctx->codec->id) {
466
 
        case CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
467
 
        case CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
468
 
        case CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
 
548
        case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
 
549
        case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
 
550
        case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
469
551
        }
470
552
        if (!s->status[0].step_index) {
471
553
            nb_samples++;
474
556
        nb_samples += buf_size * samples_per_byte / ch;
475
557
        break;
476
558
    }
477
 
    case CODEC_ID_ADPCM_SWF:
 
559
    case AV_CODEC_ID_ADPCM_SWF:
478
560
    {
479
561
        int buf_bits       = buf_size * 8 - 2;
480
 
        int nbits          = (buf[0] >> 6) + 2;
 
562
        int nbits          = (bytestream2_get_byte(gb) >> 6) + 2;
481
563
        int block_hdr_size = 22 * ch;
482
564
        int block_size     = block_hdr_size + nbits * ch * 4095;
483
565
        int nblocks        = buf_bits / block_size;
487
569
            nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
488
570
        break;
489
571
    }
490
 
    case CODEC_ID_ADPCM_THP:
 
572
    case AV_CODEC_ID_ADPCM_THP:
491
573
        has_coded_samples = 1;
492
 
        if (buf_size < 8)
493
 
            return 0;
494
 
        *coded_samples  = AV_RB32(&buf[4]);
 
574
        bytestream2_skip(gb, 4); // channel size
 
575
        *coded_samples  = bytestream2_get_be32(gb);
495
576
        *coded_samples -= *coded_samples % 14;
496
577
        nb_samples      = (buf_size - 80) / (8 * ch) * 14;
497
578
        break;
498
 
    case CODEC_ID_ADPCM_XA:
 
579
    case AV_CODEC_ID_ADPCM_XA:
499
580
        nb_samples = (buf_size / 128) * 224 / ch;
500
581
        break;
501
582
    }
507
588
    return nb_samples;
508
589
}
509
590
 
510
 
/* DK3 ADPCM support macro */
511
 
#define DK3_GET_NEXT_NIBBLE() \
512
 
    if (decode_top_nibble_next) \
513
 
    { \
514
 
        nibble = last_byte >> 4; \
515
 
        decode_top_nibble_next = 0; \
516
 
    } \
517
 
    else \
518
 
    { \
519
 
        if (end_of_packet) \
520
 
            break; \
521
 
        last_byte = *src++; \
522
 
        if (src >= buf + buf_size) \
523
 
            end_of_packet = 1; \
524
 
        nibble = last_byte & 0x0F; \
525
 
        decode_top_nibble_next = 1; \
526
 
    }
527
 
 
528
591
static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
529
592
                              int *got_frame_ptr, AVPacket *avpkt)
530
593
{
534
597
    ADPCMChannelStatus *cs;
535
598
    int n, m, channel, i;
536
599
    short *samples;
537
 
    const uint8_t *src;
 
600
    int16_t **samples_p;
538
601
    int st; /* stereo */
539
602
    int count1, count2;
540
603
    int nb_samples, coded_samples, ret;
 
604
    GetByteContext gb;
541
605
 
542
 
    nb_samples = get_nb_samples(avctx, buf, buf_size, &coded_samples);
 
606
    bytestream2_init(&gb, buf, buf_size);
 
607
    nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples);
543
608
    if (nb_samples <= 0) {
544
609
        av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
545
610
        return AVERROR_INVALIDDATA;
547
612
 
548
613
    /* get output buffer */
549
614
    c->frame.nb_samples = nb_samples;
550
 
    if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {
 
615
    if ((ret = ff_get_buffer(avctx, &c->frame)) < 0) {
551
616
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
552
617
        return ret;
553
618
    }
554
619
    samples = (short *)c->frame.data[0];
 
620
    samples_p = (int16_t **)c->frame.extended_data;
555
621
 
556
622
    /* use coded_samples when applicable */
557
623
    /* it is always <= nb_samples, so the output buffer will be large enough */
561
627
        c->frame.nb_samples = nb_samples = coded_samples;
562
628
    }
563
629
 
564
 
    src = buf;
565
 
 
566
630
    st = avctx->channels == 2 ? 1 : 0;
567
631
 
568
632
    switch(avctx->codec->id) {
569
 
    case CODEC_ID_ADPCM_IMA_QT:
 
633
    case AV_CODEC_ID_ADPCM_IMA_QT:
570
634
        /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
571
635
           Channel data is interleaved per-chunk. */
572
636
        for (channel = 0; channel < avctx->channels; channel++) {
573
 
            int16_t predictor;
 
637
            int predictor;
574
638
            int step_index;
575
639
            cs = &(c->status[channel]);
576
640
            /* (pppppp) (piiiiiii) */
577
641
 
578
642
            /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
579
 
            predictor = AV_RB16(src);
 
643
            predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
580
644
            step_index = predictor & 0x7F;
581
 
            predictor &= 0xFF80;
582
 
 
583
 
            src += 2;
 
645
            predictor &= ~0x7F;
584
646
 
585
647
            if (cs->step_index == step_index) {
586
 
                int diff = (int)predictor - cs->predictor;
 
648
                int diff = predictor - cs->predictor;
587
649
                if (diff < 0)
588
650
                    diff = - diff;
589
651
                if (diff > 0x7f)
594
656
                cs->predictor = predictor;
595
657
            }
596
658
 
597
 
            if (cs->step_index > 88){
598
 
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
599
 
                cs->step_index = 88;
 
659
            if (cs->step_index > 88u){
 
660
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
 
661
                       channel, cs->step_index);
 
662
                return AVERROR_INVALIDDATA;
600
663
            }
601
664
 
602
 
            samples = (short *)c->frame.data[0] + channel;
 
665
            samples = samples_p[channel];
603
666
 
604
 
            for (m = 0; m < 32; m++) {
605
 
                *samples = adpcm_ima_qt_expand_nibble(cs, src[0] & 0x0F, 3);
606
 
                samples += avctx->channels;
607
 
                *samples = adpcm_ima_qt_expand_nibble(cs, src[0] >> 4  , 3);
608
 
                samples += avctx->channels;
609
 
                src ++;
 
667
            for (m = 0; m < 64; m += 2) {
 
668
                int byte = bytestream2_get_byteu(&gb);
 
669
                samples[m    ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F, 3);
 
670
                samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4  , 3);
610
671
            }
611
672
        }
612
673
        break;
613
 
    case CODEC_ID_ADPCM_IMA_WAV:
614
 
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
615
 
            buf_size = avctx->block_align;
616
 
 
 
674
    case AV_CODEC_ID_ADPCM_IMA_WAV:
617
675
        for(i=0; i<avctx->channels; i++){
618
676
            cs = &(c->status[i]);
619
 
            cs->predictor = *samples++ = (int16_t)bytestream_get_le16(&src);
 
677
            cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
620
678
 
621
 
            cs->step_index = *src++;
622
 
            if (cs->step_index > 88){
623
 
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
624
 
                cs->step_index = 88;
 
679
            cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
 
680
            if (cs->step_index > 88u){
 
681
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
 
682
                       i, cs->step_index);
 
683
                return AVERROR_INVALIDDATA;
625
684
            }
626
 
            if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */
627
685
        }
628
686
 
629
 
        for (n = (nb_samples - 1) / 8; n > 0; n--) {
 
687
        for (n = 0; n < (nb_samples - 1) / 8; n++) {
630
688
            for (i = 0; i < avctx->channels; i++) {
631
689
                cs = &c->status[i];
632
 
                for (m = 0; m < 4; m++) {
633
 
                    uint8_t v = *src++;
634
 
                    *samples = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
635
 
                    samples += avctx->channels;
636
 
                    *samples = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
637
 
                    samples += avctx->channels;
 
690
                samples = &samples_p[i][1 + n * 8];
 
691
                for (m = 0; m < 8; m += 2) {
 
692
                    int v = bytestream2_get_byteu(&gb);
 
693
                    samples[m    ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
 
694
                    samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
638
695
                }
639
 
                samples -= 8 * avctx->channels - 1;
640
696
            }
641
 
            samples += 7 * avctx->channels;
642
697
        }
643
698
        break;
644
 
    case CODEC_ID_ADPCM_4XM:
 
699
    case AV_CODEC_ID_ADPCM_4XM:
645
700
        for (i = 0; i < avctx->channels; i++)
646
 
            c->status[i].predictor= (int16_t)bytestream_get_le16(&src);
 
701
            c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
647
702
 
648
703
        for (i = 0; i < avctx->channels; i++) {
649
 
            c->status[i].step_index= (int16_t)bytestream_get_le16(&src);
650
 
            c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
 
704
            c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
 
705
            if (c->status[i].step_index > 88u) {
 
706
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
 
707
                       i, c->status[i].step_index);
 
708
                return AVERROR_INVALIDDATA;
 
709
            }
651
710
        }
652
711
 
653
712
        for (i = 0; i < avctx->channels; i++) {
654
 
            samples = (short *)c->frame.data[0] + i;
 
713
            samples = (int16_t *)c->frame.data[i];
655
714
            cs = &c->status[i];
656
 
            for (n = nb_samples >> 1; n > 0; n--, src++) {
657
 
                uint8_t v = *src;
658
 
                *samples = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
659
 
                samples += avctx->channels;
660
 
                *samples = adpcm_ima_expand_nibble(cs, v >> 4  , 4);
661
 
                samples += avctx->channels;
 
715
            for (n = nb_samples >> 1; n > 0; n--) {
 
716
                int v = bytestream2_get_byteu(&gb);
 
717
                *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
 
718
                *samples++ = adpcm_ima_expand_nibble(cs, v >> 4  , 4);
662
719
            }
663
720
        }
664
721
        break;
665
 
    case CODEC_ID_ADPCM_MS:
 
722
    case AV_CODEC_ID_ADPCM_MS:
666
723
    {
667
724
        int block_predictor;
668
725
 
669
 
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
670
 
            buf_size = avctx->block_align;
671
 
 
672
 
        block_predictor = av_clip(*src++, 0, 6);
 
726
        block_predictor = bytestream2_get_byteu(&gb);
 
727
        if (block_predictor > 6) {
 
728
            av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
 
729
                   block_predictor);
 
730
            return AVERROR_INVALIDDATA;
 
731
        }
673
732
        c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
674
733
        c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
675
734
        if (st) {
676
 
            block_predictor = av_clip(*src++, 0, 6);
 
735
            block_predictor = bytestream2_get_byteu(&gb);
 
736
            if (block_predictor > 6) {
 
737
                av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
 
738
                       block_predictor);
 
739
                return AVERROR_INVALIDDATA;
 
740
            }
677
741
            c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
678
742
            c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
679
743
        }
680
 
        c->status[0].idelta = (int16_t)bytestream_get_le16(&src);
 
744
        c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
681
745
        if (st){
682
 
            c->status[1].idelta = (int16_t)bytestream_get_le16(&src);
 
746
            c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
683
747
        }
684
748
 
685
 
        c->status[0].sample1 = bytestream_get_le16(&src);
686
 
        if (st) c->status[1].sample1 = bytestream_get_le16(&src);
687
 
        c->status[0].sample2 = bytestream_get_le16(&src);
688
 
        if (st) c->status[1].sample2 = bytestream_get_le16(&src);
 
749
        c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
 
750
        if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
 
751
        c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
 
752
        if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
689
753
 
690
754
        *samples++ = c->status[0].sample2;
691
755
        if (st) *samples++ = c->status[1].sample2;
692
756
        *samples++ = c->status[0].sample1;
693
757
        if (st) *samples++ = c->status[1].sample1;
694
 
        for(n = (nb_samples - 2) >> (1 - st); n > 0; n--, src++) {
695
 
            *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], src[0] >> 4  );
696
 
            *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
 
758
        for(n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
 
759
            int byte = bytestream2_get_byteu(&gb);
 
760
            *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4  );
 
761
            *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
697
762
        }
698
763
        break;
699
764
    }
700
 
    case CODEC_ID_ADPCM_IMA_DK4:
701
 
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
702
 
            buf_size = avctx->block_align;
703
 
 
 
765
    case AV_CODEC_ID_ADPCM_IMA_DK4:
704
766
        for (channel = 0; channel < avctx->channels; channel++) {
705
767
            cs = &c->status[channel];
706
 
            cs->predictor  = (int16_t)bytestream_get_le16(&src);
707
 
            cs->step_index = av_clip(*src++, 0, 88);
708
 
            src++;
709
 
            *samples++ = cs->predictor;
 
768
            cs->predictor  = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
 
769
            cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
 
770
            if (cs->step_index > 88u){
 
771
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
 
772
                       channel, cs->step_index);
 
773
                return AVERROR_INVALIDDATA;
 
774
            }
710
775
        }
711
 
        for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
712
 
            uint8_t v = *src;
 
776
        for (n = (nb_samples >> (1 - st)) - 1; n > 0; n--) {
 
777
            int v = bytestream2_get_byteu(&gb);
713
778
            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4  , 3);
714
779
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
715
780
        }
716
781
        break;
717
 
    case CODEC_ID_ADPCM_IMA_DK3:
 
782
    case AV_CODEC_ID_ADPCM_IMA_DK3:
718
783
    {
719
 
        unsigned char last_byte = 0;
720
 
        unsigned char nibble;
 
784
        int last_byte = 0;
 
785
        int nibble;
721
786
        int decode_top_nibble_next = 0;
722
 
        int end_of_packet = 0;
723
787
        int diff_channel;
724
 
 
725
 
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
726
 
            buf_size = avctx->block_align;
727
 
 
728
 
        c->status[0].predictor  = (int16_t)AV_RL16(src + 10);
729
 
        c->status[1].predictor  = (int16_t)AV_RL16(src + 12);
730
 
        c->status[0].step_index = av_clip(src[14], 0, 88);
731
 
        c->status[1].step_index = av_clip(src[15], 0, 88);
 
788
        const int16_t *samples_end = samples + avctx->channels * nb_samples;
 
789
 
 
790
        bytestream2_skipu(&gb, 10);
 
791
        c->status[0].predictor  = sign_extend(bytestream2_get_le16u(&gb), 16);
 
792
        c->status[1].predictor  = sign_extend(bytestream2_get_le16u(&gb), 16);
 
793
        c->status[0].step_index = bytestream2_get_byteu(&gb);
 
794
        c->status[1].step_index = bytestream2_get_byteu(&gb);
 
795
        if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
 
796
            av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
 
797
                   c->status[0].step_index, c->status[1].step_index);
 
798
            return AVERROR_INVALIDDATA;
 
799
        }
732
800
        /* sign extend the predictors */
733
 
        src += 16;
734
801
        diff_channel = c->status[1].predictor;
735
802
 
736
 
        /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
737
 
         * the buffer is consumed */
738
 
        while (1) {
 
803
        /* DK3 ADPCM support macro */
 
804
#define DK3_GET_NEXT_NIBBLE() \
 
805
    if (decode_top_nibble_next) { \
 
806
        nibble = last_byte >> 4; \
 
807
        decode_top_nibble_next = 0; \
 
808
    } else { \
 
809
        last_byte = bytestream2_get_byteu(&gb); \
 
810
        nibble = last_byte & 0x0F; \
 
811
        decode_top_nibble_next = 1; \
 
812
    }
 
813
 
 
814
        while (samples < samples_end) {
739
815
 
740
816
            /* for this algorithm, c->status[0] is the sum channel and
741
817
             * c->status[1] is the diff channel */
764
840
        }
765
841
        break;
766
842
    }
767
 
    case CODEC_ID_ADPCM_IMA_ISS:
 
843
    case AV_CODEC_ID_ADPCM_IMA_ISS:
768
844
        for (channel = 0; channel < avctx->channels; channel++) {
769
845
            cs = &c->status[channel];
770
 
            cs->predictor  = (int16_t)bytestream_get_le16(&src);
771
 
            cs->step_index = av_clip(*src++, 0, 88);
772
 
            src++;
 
846
            cs->predictor  = sign_extend(bytestream2_get_le16u(&gb), 16);
 
847
            cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
 
848
            if (cs->step_index > 88u){
 
849
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
 
850
                       channel, cs->step_index);
 
851
                return AVERROR_INVALIDDATA;
 
852
            }
773
853
        }
774
854
 
775
 
        for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
776
 
            uint8_t v1, v2;
777
 
            uint8_t v = *src;
 
855
        for (n = nb_samples >> (1 - st); n > 0; n--) {
 
856
            int v1, v2;
 
857
            int v = bytestream2_get_byteu(&gb);
778
858
            /* nibbles are swapped for mono */
779
859
            if (st) {
780
860
                v1 = v >> 4;
787
867
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
788
868
        }
789
869
        break;
790
 
    case CODEC_ID_ADPCM_IMA_WS:
791
 
        while (src < buf + buf_size) {
792
 
            uint8_t v = *src++;
 
870
    case AV_CODEC_ID_ADPCM_IMA_APC:
 
871
        while (bytestream2_get_bytes_left(&gb) > 0) {
 
872
            int v = bytestream2_get_byteu(&gb);
793
873
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  v >> 4  , 3);
794
874
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
795
875
        }
796
876
        break;
797
 
    case CODEC_ID_ADPCM_XA:
798
 
        while (buf_size >= 128) {
799
 
            if ((ret = xa_decode(avctx, samples, src, &c->status[0],
800
 
                                 &c->status[1], avctx->channels)) < 0)
 
877
    case AV_CODEC_ID_ADPCM_IMA_WS:
 
878
        if (c->vqa_version == 3) {
 
879
            for (channel = 0; channel < avctx->channels; channel++) {
 
880
                int16_t *smp = samples_p[channel];
 
881
 
 
882
                for (n = nb_samples / 2; n > 0; n--) {
 
883
                    int v = bytestream2_get_byteu(&gb);
 
884
                    *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4  , 3);
 
885
                    *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
 
886
                }
 
887
            }
 
888
        } else {
 
889
            for (n = nb_samples / 2; n > 0; n--) {
 
890
                for (channel = 0; channel < avctx->channels; channel++) {
 
891
                    int v = bytestream2_get_byteu(&gb);
 
892
                    *samples++  = adpcm_ima_expand_nibble(&c->status[channel], v >> 4  , 3);
 
893
                    samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
 
894
                }
 
895
                samples += avctx->channels;
 
896
            }
 
897
        }
 
898
        bytestream2_seek(&gb, 0, SEEK_END);
 
899
        break;
 
900
    case AV_CODEC_ID_ADPCM_XA:
 
901
    {
 
902
        int16_t *out0 = samples_p[0];
 
903
        int16_t *out1 = samples_p[1];
 
904
        int samples_per_block = 28 * (3 - avctx->channels) * 4;
 
905
        int sample_offset = 0;
 
906
        while (bytestream2_get_bytes_left(&gb) >= 128) {
 
907
            if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
 
908
                                 &c->status[0], &c->status[1],
 
909
                                 avctx->channels, sample_offset)) < 0)
801
910
                return ret;
802
 
            src += 128;
803
 
            samples += 28 * 8;
804
 
            buf_size -= 128;
805
 
        }
806
 
        break;
807
 
    case CODEC_ID_ADPCM_IMA_EA_EACS:
808
 
        src += 4; // skip sample count (already read)
809
 
 
810
 
        for (i=0; i<=st; i++)
811
 
            c->status[i].step_index = av_clip(bytestream_get_le32(&src), 0, 88);
812
 
        for (i=0; i<=st; i++)
813
 
            c->status[i].predictor  = bytestream_get_le32(&src);
814
 
 
815
 
        for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
816
 
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  *src>>4,   3);
817
 
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], *src&0x0F, 3);
818
 
        }
819
 
        break;
820
 
    case CODEC_ID_ADPCM_IMA_EA_SEAD:
821
 
        for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
822
 
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] >> 4, 6);
823
 
            *samples++ = adpcm_ima_expand_nibble(&c->status[st],src[0]&0x0F, 6);
824
 
        }
825
 
        break;
826
 
    case CODEC_ID_ADPCM_EA:
 
911
            bytestream2_skipu(&gb, 128);
 
912
            sample_offset += samples_per_block;
 
913
        }
 
914
        break;
 
915
    }
 
916
    case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
 
917
        for (i=0; i<=st; i++) {
 
918
            c->status[i].step_index = bytestream2_get_le32u(&gb);
 
919
            if (c->status[i].step_index > 88u) {
 
920
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
 
921
                       i, c->status[i].step_index);
 
922
                return AVERROR_INVALIDDATA;
 
923
            }
 
924
        }
 
925
        for (i=0; i<=st; i++)
 
926
            c->status[i].predictor  = bytestream2_get_le32u(&gb);
 
927
 
 
928
        for (n = nb_samples >> (1 - st); n > 0; n--) {
 
929
            int byte   = bytestream2_get_byteu(&gb);
 
930
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  byte >> 4,   3);
 
931
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
 
932
        }
 
933
        break;
 
934
    case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
 
935
        for (n = nb_samples >> (1 - st); n > 0; n--) {
 
936
            int byte = bytestream2_get_byteu(&gb);
 
937
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  byte >> 4,   6);
 
938
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
 
939
        }
 
940
        break;
 
941
    case AV_CODEC_ID_ADPCM_EA:
827
942
    {
828
 
        int32_t previous_left_sample, previous_right_sample;
829
 
        int32_t current_left_sample, current_right_sample;
830
 
        int32_t next_left_sample, next_right_sample;
831
 
        int32_t coeff1l, coeff2l, coeff1r, coeff2r;
832
 
        uint8_t shift_left, shift_right;
 
943
        int previous_left_sample, previous_right_sample;
 
944
        int current_left_sample, current_right_sample;
 
945
        int next_left_sample, next_right_sample;
 
946
        int coeff1l, coeff2l, coeff1r, coeff2r;
 
947
        int shift_left, shift_right;
833
948
 
834
949
        /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
835
950
           each coding 28 stereo samples. */
836
951
 
837
 
        src += 4; // skip sample count (already read)
838
 
 
839
 
        current_left_sample   = (int16_t)bytestream_get_le16(&src);
840
 
        previous_left_sample  = (int16_t)bytestream_get_le16(&src);
841
 
        current_right_sample  = (int16_t)bytestream_get_le16(&src);
842
 
        previous_right_sample = (int16_t)bytestream_get_le16(&src);
 
952
        current_left_sample   = sign_extend(bytestream2_get_le16u(&gb), 16);
 
953
        previous_left_sample  = sign_extend(bytestream2_get_le16u(&gb), 16);
 
954
        current_right_sample  = sign_extend(bytestream2_get_le16u(&gb), 16);
 
955
        previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
843
956
 
844
957
        for (count1 = 0; count1 < nb_samples / 28; count1++) {
845
 
            coeff1l = ea_adpcm_table[ *src >> 4       ];
846
 
            coeff2l = ea_adpcm_table[(*src >> 4  ) + 4];
847
 
            coeff1r = ea_adpcm_table[*src & 0x0F];
848
 
            coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
849
 
            src++;
 
958
            int byte = bytestream2_get_byteu(&gb);
 
959
            coeff1l = ea_adpcm_table[ byte >> 4       ];
 
960
            coeff2l = ea_adpcm_table[(byte >> 4  ) + 4];
 
961
            coeff1r = ea_adpcm_table[ byte & 0x0F];
 
962
            coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];
850
963
 
851
 
            shift_left  = 20 - (*src >> 4);
852
 
            shift_right = 20 - (*src & 0x0F);
853
 
            src++;
 
964
            byte = bytestream2_get_byteu(&gb);
 
965
            shift_left  = 20 - (byte >> 4);
 
966
            shift_right = 20 - (byte & 0x0F);
854
967
 
855
968
            for (count2 = 0; count2 < 28; count2++) {
856
 
                next_left_sample  = sign_extend(*src >> 4, 4) << shift_left;
857
 
                next_right_sample = sign_extend(*src,      4) << shift_right;
858
 
                src++;
 
969
                byte = bytestream2_get_byteu(&gb);
 
970
                next_left_sample  = sign_extend(byte >> 4, 4) << shift_left;
 
971
                next_right_sample = sign_extend(byte,      4) << shift_right;
859
972
 
860
973
                next_left_sample = (next_left_sample +
861
974
                    (current_left_sample * coeff1l) +
868
981
                current_left_sample = av_clip_int16(next_left_sample);
869
982
                previous_right_sample = current_right_sample;
870
983
                current_right_sample = av_clip_int16(next_right_sample);
871
 
                *samples++ = (unsigned short)current_left_sample;
872
 
                *samples++ = (unsigned short)current_right_sample;
 
984
                *samples++ = current_left_sample;
 
985
                *samples++ = current_right_sample;
873
986
            }
874
987
        }
875
988
 
876
 
        if (src - buf == buf_size - 2)
877
 
            src += 2; // Skip terminating 0x0000
 
989
        bytestream2_skip(&gb, 2); // Skip terminating 0x0000
878
990
 
879
991
        break;
880
992
    }
881
 
    case CODEC_ID_ADPCM_EA_MAXIS_XA:
 
993
    case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
882
994
    {
883
995
        int coeff[2][2], shift[2];
884
996
 
885
997
        for(channel = 0; channel < avctx->channels; channel++) {
 
998
            int byte = bytestream2_get_byteu(&gb);
886
999
            for (i=0; i<2; i++)
887
 
                coeff[channel][i] = ea_adpcm_table[(*src >> 4) + 4*i];
888
 
            shift[channel] = 20 - (*src & 0x0F);
889
 
            src++;
 
1000
                coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
 
1001
            shift[channel] = 20 - (byte & 0x0F);
890
1002
        }
891
1003
        for (count1 = 0; count1 < nb_samples / 2; count1++) {
 
1004
            int byte[2];
 
1005
 
 
1006
            byte[0] = bytestream2_get_byteu(&gb);
 
1007
            if (st) byte[1] = bytestream2_get_byteu(&gb);
892
1008
            for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
893
1009
                for(channel = 0; channel < avctx->channels; channel++) {
894
 
                    int32_t sample = sign_extend(src[channel] >> i, 4) << shift[channel];
 
1010
                    int sample = sign_extend(byte[channel] >> i, 4) << shift[channel];
895
1011
                    sample = (sample +
896
1012
                             c->status[channel].sample1 * coeff[channel][0] +
897
1013
                             c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
900
1016
                    *samples++ = c->status[channel].sample1;
901
1017
                }
902
1018
            }
903
 
            src+=avctx->channels;
904
1019
        }
905
 
        /* consume whole packet */
906
 
        src = buf + buf_size;
 
1020
        bytestream2_seek(&gb, 0, SEEK_END);
907
1021
        break;
908
1022
    }
909
 
    case CODEC_ID_ADPCM_EA_R1:
910
 
    case CODEC_ID_ADPCM_EA_R2:
911
 
    case CODEC_ID_ADPCM_EA_R3: {
 
1023
    case AV_CODEC_ID_ADPCM_EA_R1:
 
1024
    case AV_CODEC_ID_ADPCM_EA_R2:
 
1025
    case AV_CODEC_ID_ADPCM_EA_R3: {
912
1026
        /* channel numbering
913
1027
           2chan: 0=fl, 1=fr
914
1028
           4chan: 0=fl, 1=rl, 2=fr, 3=rr
915
1029
           6chan: 0=fl, 1=c,  2=fr, 3=rl,  4=rr, 5=sub */
916
 
        const int big_endian = avctx->codec->id == CODEC_ID_ADPCM_EA_R3;
917
 
        int32_t previous_sample, current_sample, next_sample;
918
 
        int32_t coeff1, coeff2;
919
 
        uint8_t shift;
 
1030
        const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
 
1031
        int previous_sample, current_sample, next_sample;
 
1032
        int coeff1, coeff2;
 
1033
        int shift;
920
1034
        unsigned int channel;
921
1035
        uint16_t *samplesC;
922
 
        const uint8_t *srcC;
923
 
        const uint8_t *src_end = buf + buf_size;
924
1036
        int count = 0;
 
1037
        int offsets[6];
925
1038
 
926
 
        src += 4; // skip sample count (already read)
 
1039
        for (channel=0; channel<avctx->channels; channel++)
 
1040
            offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
 
1041
                                             bytestream2_get_le32(&gb)) +
 
1042
                               (avctx->channels + 1) * 4;
927
1043
 
928
1044
        for (channel=0; channel<avctx->channels; channel++) {
929
 
            int32_t offset = (big_endian ? bytestream_get_be32(&src)
930
 
                                         : bytestream_get_le32(&src))
931
 
                           + (avctx->channels-channel-1) * 4;
932
 
 
933
 
            if ((offset < 0) || (offset >= src_end - src - 4)) break;
934
 
            srcC  = src + offset;
935
 
            samplesC = samples + channel;
936
 
 
937
 
            if (avctx->codec->id == CODEC_ID_ADPCM_EA_R1) {
938
 
                current_sample  = (int16_t)bytestream_get_le16(&srcC);
939
 
                previous_sample = (int16_t)bytestream_get_le16(&srcC);
 
1045
            bytestream2_seek(&gb, offsets[channel], SEEK_SET);
 
1046
            samplesC = samples_p[channel];
 
1047
 
 
1048
            if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
 
1049
                current_sample  = sign_extend(bytestream2_get_le16(&gb), 16);
 
1050
                previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
940
1051
            } else {
941
1052
                current_sample  = c->status[channel].predictor;
942
1053
                previous_sample = c->status[channel].prev_sample;
943
1054
            }
944
1055
 
945
1056
            for (count1 = 0; count1 < nb_samples / 28; count1++) {
946
 
                if (*srcC == 0xEE) {  /* only seen in R2 and R3 */
947
 
                    srcC++;
948
 
                    if (srcC > src_end - 30*2) break;
949
 
                    current_sample  = (int16_t)bytestream_get_be16(&srcC);
950
 
                    previous_sample = (int16_t)bytestream_get_be16(&srcC);
 
1057
                int byte = bytestream2_get_byte(&gb);
 
1058
                if (byte == 0xEE) {  /* only seen in R2 and R3 */
 
1059
                    current_sample  = sign_extend(bytestream2_get_be16(&gb), 16);
 
1060
                    previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);
951
1061
 
952
 
                    for (count2=0; count2<28; count2++) {
953
 
                        *samplesC = (int16_t)bytestream_get_be16(&srcC);
954
 
                        samplesC += avctx->channels;
955
 
                    }
 
1062
                    for (count2=0; count2<28; count2++)
 
1063
                        *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
956
1064
                } else {
957
 
                    coeff1 = ea_adpcm_table[ *srcC>>4     ];
958
 
                    coeff2 = ea_adpcm_table[(*srcC>>4) + 4];
959
 
                    shift = 20 - (*srcC++ & 0x0F);
 
1065
                    coeff1 = ea_adpcm_table[ byte >> 4     ];
 
1066
                    coeff2 = ea_adpcm_table[(byte >> 4) + 4];
 
1067
                    shift = 20 - (byte & 0x0F);
960
1068
 
961
 
                    if (srcC > src_end - 14) break;
962
1069
                    for (count2=0; count2<28; count2++) {
963
1070
                        if (count2 & 1)
964
 
                            next_sample = sign_extend(*srcC++,    4) << shift;
965
 
                        else
966
 
                            next_sample = sign_extend(*srcC >> 4, 4) << shift;
 
1071
                            next_sample = sign_extend(byte,    4) << shift;
 
1072
                        else {
 
1073
                            byte = bytestream2_get_byte(&gb);
 
1074
                            next_sample = sign_extend(byte >> 4, 4) << shift;
 
1075
                        }
967
1076
 
968
1077
                        next_sample += (current_sample  * coeff1) +
969
1078
                                       (previous_sample * coeff2);
971
1080
 
972
1081
                        previous_sample = current_sample;
973
1082
                        current_sample  = next_sample;
974
 
                        *samplesC = current_sample;
975
 
                        samplesC += avctx->channels;
 
1083
                        *samplesC++ = current_sample;
976
1084
                    }
977
1085
                }
978
1086
            }
983
1091
                count = FFMAX(count, count1);
984
1092
            }
985
1093
 
986
 
            if (avctx->codec->id != CODEC_ID_ADPCM_EA_R1) {
 
1094
            if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
987
1095
                c->status[channel].predictor   = current_sample;
988
1096
                c->status[channel].prev_sample = previous_sample;
989
1097
            }
990
1098
        }
991
1099
 
992
1100
        c->frame.nb_samples = count * 28;
993
 
        src = src_end;
 
1101
        bytestream2_seek(&gb, 0, SEEK_END);
994
1102
        break;
995
1103
    }
996
 
    case CODEC_ID_ADPCM_EA_XAS:
 
1104
    case AV_CODEC_ID_ADPCM_EA_XAS:
997
1105
        for (channel=0; channel<avctx->channels; channel++) {
998
1106
            int coeff[2][4], shift[4];
999
 
            short *s2, *s = &samples[channel];
1000
 
            for (n=0; n<4; n++, s+=32*avctx->channels) {
 
1107
            int16_t *s = samples_p[channel];
 
1108
            for (n = 0; n < 4; n++, s += 32) {
 
1109
                int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1001
1110
                for (i=0; i<2; i++)
1002
 
                    coeff[i][n] = ea_adpcm_table[(src[0]&0x0F)+4*i];
1003
 
                shift[n] = 20 - (src[2] & 0x0F);
1004
 
                for (s2=s, i=0; i<2; i++, src+=2, s2+=avctx->channels)
1005
 
                    s2[0] = (src[0]&0xF0) + (src[1]<<8);
 
1111
                    coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];
 
1112
                s[0] = val & ~0x0F;
 
1113
 
 
1114
                val = sign_extend(bytestream2_get_le16u(&gb), 16);
 
1115
                shift[n] = 20 - (val & 0x0F);
 
1116
                s[1] = val & ~0x0F;
1006
1117
            }
1007
1118
 
1008
1119
            for (m=2; m<32; m+=2) {
1009
 
                s = &samples[m*avctx->channels + channel];
1010
 
                for (n=0; n<4; n++, src++, s+=32*avctx->channels) {
1011
 
                    for (s2=s, i=0; i<8; i+=4, s2+=avctx->channels) {
1012
 
                        int level = sign_extend(*src >> (4 - i), 4) << shift[n];
1013
 
                        int pred  = s2[-1*avctx->channels] * coeff[0][n]
1014
 
                                  + s2[-2*avctx->channels] * coeff[1][n];
1015
 
                        s2[0] = av_clip_int16((level + pred + 0x80) >> 8);
1016
 
                    }
 
1120
                s = &samples_p[channel][m];
 
1121
                for (n = 0; n < 4; n++, s += 32) {
 
1122
                    int level, pred;
 
1123
                    int byte = bytestream2_get_byteu(&gb);
 
1124
 
 
1125
                    level = sign_extend(byte >> 4, 4) << shift[n];
 
1126
                    pred  = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
 
1127
                    s[0]  = av_clip_int16((level + pred + 0x80) >> 8);
 
1128
 
 
1129
                    level = sign_extend(byte, 4) << shift[n];
 
1130
                    pred  = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
 
1131
                    s[1]  = av_clip_int16((level + pred + 0x80) >> 8);
1017
1132
                }
1018
1133
            }
1019
1134
        }
1020
1135
        break;
1021
 
    case CODEC_ID_ADPCM_IMA_AMV:
1022
 
    case CODEC_ID_ADPCM_IMA_SMJPEG:
1023
 
        if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) {
1024
 
            c->status[0].predictor = sign_extend(bytestream_get_le16(&src), 16);
1025
 
            c->status[0].step_index = av_clip(bytestream_get_le16(&src), 0, 88);
1026
 
            src += 4;
 
1136
    case AV_CODEC_ID_ADPCM_IMA_AMV:
 
1137
    case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
 
1138
        if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
 
1139
            c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
 
1140
            c->status[0].step_index = bytestream2_get_le16u(&gb);
 
1141
            bytestream2_skipu(&gb, 4);
1027
1142
        } else {
1028
 
            c->status[0].predictor = sign_extend(bytestream_get_be16(&src), 16);
1029
 
            c->status[0].step_index = av_clip(bytestream_get_byte(&src), 0, 88);
1030
 
            src += 1;
1031
 
        }
1032
 
 
1033
 
        for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1034
 
            char hi, lo;
1035
 
            lo = *src & 0x0F;
1036
 
            hi = *src >> 4;
1037
 
 
1038
 
            if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV)
1039
 
                FFSWAP(char, hi, lo);
1040
 
 
1041
 
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1042
 
                lo, 3);
1043
 
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1044
 
                hi, 3);
 
1143
            c->status[0].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
 
1144
            c->status[0].step_index = bytestream2_get_byteu(&gb);
 
1145
            bytestream2_skipu(&gb, 1);
 
1146
        }
 
1147
        if (c->status[0].step_index > 88u) {
 
1148
            av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
 
1149
                   c->status[0].step_index);
 
1150
            return AVERROR_INVALIDDATA;
 
1151
        }
 
1152
 
 
1153
        for (n = nb_samples >> (1 - st); n > 0; n--) {
 
1154
            int hi, lo, v = bytestream2_get_byteu(&gb);
 
1155
 
 
1156
            if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
 
1157
                hi = v & 0x0F;
 
1158
                lo = v >> 4;
 
1159
            } else {
 
1160
                lo = v & 0x0F;
 
1161
                hi = v >> 4;
 
1162
            }
 
1163
 
 
1164
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], lo, 3);
 
1165
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], hi, 3);
1045
1166
        }
1046
1167
        break;
1047
 
    case CODEC_ID_ADPCM_CT:
1048
 
        for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1049
 
            uint8_t v = *src;
 
1168
    case AV_CODEC_ID_ADPCM_CT:
 
1169
        for (n = nb_samples >> (1 - st); n > 0; n--) {
 
1170
            int v = bytestream2_get_byteu(&gb);
1050
1171
            *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4  );
1051
1172
            *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1052
1173
        }
1053
1174
        break;
1054
 
    case CODEC_ID_ADPCM_SBPRO_4:
1055
 
    case CODEC_ID_ADPCM_SBPRO_3:
1056
 
    case CODEC_ID_ADPCM_SBPRO_2:
 
1175
    case AV_CODEC_ID_ADPCM_SBPRO_4:
 
1176
    case AV_CODEC_ID_ADPCM_SBPRO_3:
 
1177
    case AV_CODEC_ID_ADPCM_SBPRO_2:
1057
1178
        if (!c->status[0].step_index) {
1058
1179
            /* the first byte is a raw sample */
1059
 
            *samples++ = 128 * (*src++ - 0x80);
 
1180
            *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1060
1181
            if (st)
1061
 
              *samples++ = 128 * (*src++ - 0x80);
 
1182
                *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1062
1183
            c->status[0].step_index = 1;
1063
1184
            nb_samples--;
1064
1185
        }
1065
 
        if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) {
1066
 
            for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
 
1186
        if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
 
1187
            for (n = nb_samples >> (1 - st); n > 0; n--) {
 
1188
                int byte = bytestream2_get_byteu(&gb);
1067
1189
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1068
 
                    src[0] >> 4, 4, 0);
 
1190
                                                       byte >> 4,   4, 0);
1069
1191
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1070
 
                    src[0] & 0x0F, 4, 0);
 
1192
                                                       byte & 0x0F, 4, 0);
1071
1193
            }
1072
 
        } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) {
1073
 
            for (n = nb_samples / 3; n > 0; n--, src++) {
1074
 
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1075
 
                     src[0] >> 5        , 3, 0);
1076
 
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1077
 
                    (src[0] >> 2) & 0x07, 3, 0);
1078
 
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1079
 
                    src[0] & 0x03, 2, 0);
 
1194
        } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
 
1195
            for (n = nb_samples / 3; n > 0; n--) {
 
1196
                int byte = bytestream2_get_byteu(&gb);
 
1197
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
 
1198
                                                        byte >> 5        , 3, 0);
 
1199
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
 
1200
                                                       (byte >> 2) & 0x07, 3, 0);
 
1201
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
 
1202
                                                        byte & 0x03,       2, 0);
1080
1203
            }
1081
1204
        } else {
1082
 
            for (n = nb_samples >> (2 - st); n > 0; n--, src++) {
1083
 
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1084
 
                     src[0] >> 6        , 2, 2);
1085
 
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1086
 
                    (src[0] >> 4) & 0x03, 2, 2);
1087
 
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1088
 
                    (src[0] >> 2) & 0x03, 2, 2);
1089
 
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1090
 
                    src[0] & 0x03, 2, 2);
1091
 
            }
1092
 
        }
1093
 
        break;
1094
 
    case CODEC_ID_ADPCM_SWF:
1095
 
    {
1096
 
        GetBitContext gb;
1097
 
        const int *table;
1098
 
        int k0, signmask, nb_bits, count;
1099
 
        int size = buf_size*8;
1100
 
 
1101
 
        init_get_bits(&gb, buf, size);
1102
 
 
1103
 
        //read bits & initial values
1104
 
        nb_bits = get_bits(&gb, 2)+2;
1105
 
        //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits);
1106
 
        table = swf_index_tables[nb_bits-2];
1107
 
        k0 = 1 << (nb_bits-2);
1108
 
        signmask = 1 << (nb_bits-1);
1109
 
 
1110
 
        while (get_bits_count(&gb) <= size - 22*avctx->channels) {
1111
 
            for (i = 0; i < avctx->channels; i++) {
1112
 
                *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
1113
 
                c->status[i].step_index = get_bits(&gb, 6);
1114
 
            }
1115
 
 
1116
 
            for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
1117
 
                int i;
1118
 
 
1119
 
                for (i = 0; i < avctx->channels; i++) {
1120
 
                    // similar to IMA adpcm
1121
 
                    int delta = get_bits(&gb, nb_bits);
1122
 
                    int step = ff_adpcm_step_table[c->status[i].step_index];
1123
 
                    long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
1124
 
                    int k = k0;
1125
 
 
1126
 
                    do {
1127
 
                        if (delta & k)
1128
 
                            vpdiff += step;
1129
 
                        step >>= 1;
1130
 
                        k >>= 1;
1131
 
                    } while(k);
1132
 
                    vpdiff += step;
1133
 
 
1134
 
                    if (delta & signmask)
1135
 
                        c->status[i].predictor -= vpdiff;
1136
 
                    else
1137
 
                        c->status[i].predictor += vpdiff;
1138
 
 
1139
 
                    c->status[i].step_index += table[delta & (~signmask)];
1140
 
 
1141
 
                    c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
1142
 
                    c->status[i].predictor = av_clip_int16(c->status[i].predictor);
1143
 
 
1144
 
                    *samples++ = c->status[i].predictor;
1145
 
                }
1146
 
            }
1147
 
        }
1148
 
        src += buf_size;
1149
 
        break;
1150
 
    }
1151
 
    case CODEC_ID_ADPCM_YAMAHA:
1152
 
        for (n = nb_samples >> (1 - st); n > 0; n--, src++) {
1153
 
            uint8_t v = *src;
 
1205
            for (n = nb_samples >> (2 - st); n > 0; n--) {
 
1206
                int byte = bytestream2_get_byteu(&gb);
 
1207
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
 
1208
                                                        byte >> 6        , 2, 2);
 
1209
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
 
1210
                                                       (byte >> 4) & 0x03, 2, 2);
 
1211
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
 
1212
                                                       (byte >> 2) & 0x03, 2, 2);
 
1213
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
 
1214
                                                        byte & 0x03,       2, 2);
 
1215
            }
 
1216
        }
 
1217
        break;
 
1218
    case AV_CODEC_ID_ADPCM_SWF:
 
1219
        adpcm_swf_decode(avctx, buf, buf_size, samples);
 
1220
        bytestream2_seek(&gb, 0, SEEK_END);
 
1221
        break;
 
1222
    case AV_CODEC_ID_ADPCM_YAMAHA:
 
1223
        for (n = nb_samples >> (1 - st); n > 0; n--) {
 
1224
            int v = bytestream2_get_byteu(&gb);
1154
1225
            *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
1155
1226
            *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4  );
1156
1227
        }
1157
1228
        break;
1158
 
    case CODEC_ID_ADPCM_THP:
 
1229
    case AV_CODEC_ID_ADPCM_THP:
1159
1230
    {
1160
1231
        int table[2][16];
1161
1232
        int prev[2][2];
1162
1233
        int ch;
1163
1234
 
1164
 
        src += 4; // skip channel size
1165
 
        src += 4; // skip number of samples (already read)
1166
 
 
1167
 
        for (i = 0; i < 32; i++)
1168
 
            table[0][i] = (int16_t)bytestream_get_be16(&src);
 
1235
        for (i = 0; i < 2; i++)
 
1236
            for (n = 0; n < 16; n++)
 
1237
                table[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16);
1169
1238
 
1170
1239
        /* Initialize the previous sample.  */
1171
 
        for (i = 0; i < 4; i++)
1172
 
            prev[0][i] = (int16_t)bytestream_get_be16(&src);
 
1240
        for (i = 0; i < 2; i++)
 
1241
            for (n = 0; n < 2; n++)
 
1242
                prev[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16);
1173
1243
 
1174
1244
        for (ch = 0; ch <= st; ch++) {
1175
 
            samples = (short *)c->frame.data[0] + ch;
 
1245
            samples = samples_p[ch];
1176
1246
 
1177
1247
            /* Read in every sample for this channel.  */
1178
1248
            for (i = 0; i < nb_samples / 14; i++) {
1179
 
                int index = (*src >> 4) & 7;
1180
 
                unsigned int exp = *src++ & 15;
 
1249
                int byte = bytestream2_get_byteu(&gb);
 
1250
                int index = (byte >> 4) & 7;
 
1251
                unsigned int exp = byte & 0x0F;
1181
1252
                int factor1 = table[ch][index * 2];
1182
1253
                int factor2 = table[ch][index * 2 + 1];
1183
1254
 
1184
1255
                /* Decode 14 samples.  */
1185
1256
                for (n = 0; n < 14; n++) {
1186
1257
                    int32_t sampledat;
1187
 
                    if(n&1) sampledat = sign_extend(*src++, 4);
1188
 
                    else    sampledat = sign_extend(*src >> 4, 4);
 
1258
 
 
1259
                    if (n & 1) {
 
1260
                        sampledat = sign_extend(byte, 4);
 
1261
                    } else {
 
1262
                        byte = bytestream2_get_byteu(&gb);
 
1263
                        sampledat = sign_extend(byte >> 4, 4);
 
1264
                    }
1189
1265
 
1190
1266
                    sampledat = ((prev[ch][0]*factor1
1191
1267
                                + prev[ch][1]*factor2) >> 11) + (sampledat << exp);
1192
1268
                    *samples = av_clip_int16(sampledat);
1193
1269
                    prev[ch][1] = prev[ch][0];
1194
1270
                    prev[ch][0] = *samples++;
1195
 
 
1196
 
                    /* In case of stereo, skip one sample, this sample
1197
 
                       is for the other channel.  */
1198
 
                    samples += st;
1199
1271
                }
1200
1272
            }
1201
1273
        }
1209
1281
    *got_frame_ptr   = 1;
1210
1282
    *(AVFrame *)data = c->frame;
1211
1283
 
1212
 
    return src - buf;
 
1284
    return bytestream2_tell(&gb);
1213
1285
}
1214
1286
 
1215
1287
 
1216
 
#define ADPCM_DECODER(id_, name_, long_name_)               \
 
1288
static const enum AVSampleFormat sample_fmts_s16[]  = { AV_SAMPLE_FMT_S16,
 
1289
                                                        AV_SAMPLE_FMT_NONE };
 
1290
static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16,
 
1291
                                                        AV_SAMPLE_FMT_NONE };
 
1292
static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16,
 
1293
                                                        AV_SAMPLE_FMT_S16P,
 
1294
                                                        AV_SAMPLE_FMT_NONE };
 
1295
 
 
1296
#define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \
1217
1297
AVCodec ff_ ## name_ ## _decoder = {                        \
1218
1298
    .name           = #name_,                               \
1219
1299
    .type           = AVMEDIA_TYPE_AUDIO,                   \
1223
1303
    .decode         = adpcm_decode_frame,                   \
1224
1304
    .capabilities   = CODEC_CAP_DR1,                        \
1225
1305
    .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
 
1306
    .sample_fmts    = sample_fmts_,                         \
1226
1307
}
1227
1308
 
1228
1309
/* Note: Do not forget to add new entries to the Makefile as well. */
1229
 
ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm, "ADPCM 4X Movie");
1230
 
ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct, "ADPCM Creative Technology");
1231
 
ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea, "ADPCM Electronic Arts");
1232
 
ADPCM_DECODER(CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
1233
 
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "ADPCM Electronic Arts R1");
1234
 
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "ADPCM Electronic Arts R2");
1235
 
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3");
1236
 
ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
1237
 
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV");
1238
 
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
1239
 
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
1240
 
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
1241
 
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
1242
 
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_ISS, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
1243
 
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
1244
 
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
1245
 
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
1246
 
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "ADPCM IMA Westwood");
1247
 
ADPCM_DECODER(CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
1248
 
ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
1249
 
ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
1250
 
ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
1251
 
ADPCM_DECODER(CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
1252
 
ADPCM_DECODER(CODEC_ID_ADPCM_THP, adpcm_thp, "ADPCM Nintendo Gamecube THP");
1253
 
ADPCM_DECODER(CODEC_ID_ADPCM_XA, adpcm_xa, "ADPCM CDROM XA");
1254
 
ADPCM_DECODER(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");
 
1310
ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM,         sample_fmts_s16p, adpcm_4xm,         "ADPCM 4X Movie");
 
1311
ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT,          sample_fmts_s16,  adpcm_ct,          "ADPCM Creative Technology");
 
1312
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA,          sample_fmts_s16,  adpcm_ea,          "ADPCM Electronic Arts");
 
1313
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_MAXIS_XA, sample_fmts_s16,  adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
 
1314
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1,       sample_fmts_s16p, adpcm_ea_r1,       "ADPCM Electronic Arts R1");
 
1315
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R2,       sample_fmts_s16p, adpcm_ea_r2,       "ADPCM Electronic Arts R2");
 
1316
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R3,       sample_fmts_s16p, adpcm_ea_r3,       "ADPCM Electronic Arts R3");
 
1317
ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS,      sample_fmts_s16p, adpcm_ea_xas,      "ADPCM Electronic Arts XAS");
 
1318
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_AMV,     sample_fmts_s16,  adpcm_ima_amv,     "ADPCM IMA AMV");
 
1319
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APC,     sample_fmts_s16,  adpcm_ima_apc,     "ADPCM IMA CRYO APC");
 
1320
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK3,     sample_fmts_s16,  adpcm_ima_dk3,     "ADPCM IMA Duck DK3");
 
1321
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4,     sample_fmts_s16,  adpcm_ima_dk4,     "ADPCM IMA Duck DK4");
 
1322
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_EACS, sample_fmts_s16,  adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
 
1323
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_SEAD, sample_fmts_s16,  adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
 
1324
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ISS,     sample_fmts_s16,  adpcm_ima_iss,     "ADPCM IMA Funcom ISS");
 
1325
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT,      sample_fmts_s16p, adpcm_ima_qt,      "ADPCM IMA QuickTime");
 
1326
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG,  sample_fmts_s16,  adpcm_ima_smjpeg,  "ADPCM IMA Loki SDL MJPEG");
 
1327
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV,     sample_fmts_s16p, adpcm_ima_wav,     "ADPCM IMA WAV");
 
1328
ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS,      sample_fmts_both, adpcm_ima_ws,      "ADPCM IMA Westwood");
 
1329
ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS,          sample_fmts_s16,  adpcm_ms,          "ADPCM Microsoft");
 
1330
ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2,     sample_fmts_s16,  adpcm_sbpro_2,     "ADPCM Sound Blaster Pro 2-bit");
 
1331
ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_3,     sample_fmts_s16,  adpcm_sbpro_3,     "ADPCM Sound Blaster Pro 2.6-bit");
 
1332
ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_4,     sample_fmts_s16,  adpcm_sbpro_4,     "ADPCM Sound Blaster Pro 4-bit");
 
1333
ADPCM_DECODER(AV_CODEC_ID_ADPCM_SWF,         sample_fmts_s16,  adpcm_swf,         "ADPCM Shockwave Flash");
 
1334
ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP,         sample_fmts_s16p, adpcm_thp,         "ADPCM Nintendo Gamecube THP");
 
1335
ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA,          sample_fmts_s16p, adpcm_xa,          "ADPCM CDROM XA");
 
1336
ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA,      sample_fmts_s16,  adpcm_yamaha,      "ADPCM Yamaha");