Statistics
| Branch: | Revision:

ffmpeg / libavcodec / adpcm.c @ b3bfb299

History | View | Annotate | Download (31.6 KB)

1
/*
2
 * ADPCM codecs
3
 * Copyright (c) 2001-2003 The ffmpeg Project
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
#include "avcodec.h"
20

    
21
/**
22
 * @file adpcm.c
23
 * ADPCM codecs.
24
 * First version by Francois Revol (revol@free.fr)
25
 * Fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
26
 *   by Mike Melanson (melanson@pcisys.net)
27
 * CD-ROM XA ADPCM codec by BERO
28
 * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com)
29
 *
30
 * Features and limitations:
31
 *
32
 * Reference documents:
33
 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html
34
 * http://www.geocities.com/SiliconValley/8682/aud3.txt
35
 * http://openquicktime.sourceforge.net/plugins.htm
36
 * XAnim sources (xa_codec.c) http://www.rasnaimaging.com/people/lapus/download.html
37
 * http://www.cs.ucla.edu/~leec/mediabench/applications.html
38
 * SoX source code http://home.sprynet.com/~cbagwell/sox.html
39
 *
40
 * CD-ROM XA:
41
 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html
42
 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html
43
 * readstr http://www.geocities.co.jp/Playtown/2004/
44
 */
45

    
46
#define BLKSIZE 1024
47

    
48
#define CLAMP_TO_SHORT(value) \
49
if (value > 32767) \
50
    value = 32767; \
51
else if (value < -32768) \
52
    value = -32768; \
53

    
54
/* step_table[] and index_table[] are from the ADPCM reference source */
55
/* This is the index table: */
56
static const int index_table[16] = {
57
    -1, -1, -1, -1, 2, 4, 6, 8,
58
    -1, -1, -1, -1, 2, 4, 6, 8,
59
};
60

    
61
/** 
62
 * This is the step table. Note that many programs use slight deviations from
63
 * this table, but such deviations are negligible:
64
 */
65
static const int step_table[89] = {
66
    7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
67
    19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
68
    50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
69
    130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
70
    337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
71
    876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
72
    2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
73
    5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
74
    15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
75
};
76

    
77
/* These are for MS-ADPCM */
78
/* AdaptationTable[], AdaptCoeff1[], and AdaptCoeff2[] are from libsndfile */
79
static const int AdaptationTable[] = {
80
        230, 230, 230, 230, 307, 409, 512, 614,
81
        768, 614, 512, 409, 307, 230, 230, 230
82
};
83

    
84
static const int AdaptCoeff1[] = {
85
        256, 512, 0, 192, 240, 460, 392
86
};
87

    
88
static const int AdaptCoeff2[] = {
89
        0, -256, 0, 64, 0, -208, -232
90
};
91

    
92
/* These are for CD-ROM XA ADPCM */
93
static const int xa_adpcm_table[5][2] = {
94
   {   0,   0 },
95
   {  60,   0 },
96
   { 115, -52 },
97
   {  98, -55 },
98
   { 122, -60 }
99
};
100

    
101
static int ea_adpcm_table[] = {
102
    0, 240, 460, 392, 0, 0, -208, -220, 0, 1,
103
    3, 4, 7, 8, 10, 11, 0, -1, -3, -4
104
};
105

    
106
static int ct_adpcm_table[8] = {
107
    0x00E6, 0x00E6, 0x00E6, 0x00E6,
108
    0x0133, 0x0199, 0x0200, 0x0266
109
};
110

    
111
/* end of tables */
112

    
113
typedef struct ADPCMChannelStatus {
114
    int predictor;
115
    short int step_index;
116
    int step;
117
    /* for encoding */
118
    int prev_sample;
119

    
120
    /* MS version */
121
    short sample1;
122
    short sample2;
123
    int coeff1;
124
    int coeff2;
125
    int idelta;
126
} ADPCMChannelStatus;
127

    
128
typedef struct ADPCMContext {
129
    int channel; /* for stereo MOVs, decode left, then decode right, then tell it's decoded */
130
    ADPCMChannelStatus status[2];
131
    short sample_buffer[32]; /* hold left samples while waiting for right samples */
132
} ADPCMContext;
133

    
134
/* XXX: implement encoding */
135

    
136
#ifdef CONFIG_ENCODERS
137
static int adpcm_encode_init(AVCodecContext *avctx)
138
{
139
    if (avctx->channels > 2)
140
        return -1; /* only stereo or mono =) */
141
    switch(avctx->codec->id) {
142
    case CODEC_ID_ADPCM_IMA_QT:
143
        av_log(avctx, AV_LOG_ERROR, "ADPCM: codec adpcm_ima_qt unsupported for encoding !\n");
144
        avctx->frame_size = 64; /* XXX: can multiple of avctx->channels * 64 (left and right blocks are interleaved) */
145
        return -1;
146
        break;
147
    case CODEC_ID_ADPCM_IMA_WAV:
148
        avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */
149
                                                             /* and we have 4 bytes per channel overhead */
150
        avctx->block_align = BLKSIZE;
151
        /* seems frame_size isn't taken into account... have to buffer the samples :-( */
152
        break;
153
    case CODEC_ID_ADPCM_MS:
154
        avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */
155
                                                             /* and we have 7 bytes per channel overhead */
156
        avctx->block_align = BLKSIZE;
157
        break;
158
    default:
159
        return -1;
160
        break;
161
    }
162

    
163
    avctx->coded_frame= avcodec_alloc_frame();
164
    avctx->coded_frame->key_frame= 1;
165

    
166
    return 0;
167
}
168

    
169
static int adpcm_encode_close(AVCodecContext *avctx)
170
{
171
    av_freep(&avctx->coded_frame);
172

    
173
    return 0;
174
}
175

    
176

    
177
static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample)
178
{
179
    int step_index;
180
    unsigned char nibble;
181
    
182
    int sign = 0; /* sign bit of the nibble (MSB) */
183
    int delta, predicted_delta;
184

    
185
    delta = sample - c->prev_sample;
186

    
187
    if (delta < 0) {
188
        sign = 1;
189
        delta = -delta;
190
    }
191

    
192
    step_index = c->step_index;
193

    
194
    /* nibble = 4 * delta / step_table[step_index]; */
195
    nibble = (delta << 2) / step_table[step_index];
196

    
197
    if (nibble > 7)
198
        nibble = 7;
199

    
200
    step_index += index_table[nibble];
201
    if (step_index < 0)
202
        step_index = 0;
203
    if (step_index > 88)
204
        step_index = 88;
205

    
206
    /* what the decoder will find */
207
    predicted_delta = ((step_table[step_index] * nibble) / 4) + (step_table[step_index] / 8);
208

    
209
    if (sign)
210
        c->prev_sample -= predicted_delta;
211
    else
212
        c->prev_sample += predicted_delta;
213

    
214
    CLAMP_TO_SHORT(c->prev_sample);
215

    
216

    
217
    nibble += sign << 3; /* sign * 8 */   
218

    
219
    /* save back */
220
    c->step_index = step_index;
221

    
222
    return nibble;
223
}
224

    
225
static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample)
226
{
227
    int predictor, nibble, bias;
228

    
229
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
230
    
231
    nibble= sample - predictor;
232
    if(nibble>=0) bias= c->idelta/2;
233
    else          bias=-c->idelta/2;
234
        
235
    nibble= (nibble + bias) / c->idelta;
236
    nibble= clip(nibble, -8, 7)&0x0F;
237
    
238
    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
239
    CLAMP_TO_SHORT(predictor);
240

    
241
    c->sample2 = c->sample1;
242
    c->sample1 = predictor;
243

    
244
    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
245
    if (c->idelta < 16) c->idelta = 16;
246

    
247
    return nibble;
248
}
249

    
250
static int adpcm_encode_frame(AVCodecContext *avctx,
251
                            unsigned char *frame, int buf_size, void *data)
252
{
253
    int n, i, st;
254
    short *samples;
255
    unsigned char *dst;
256
    ADPCMContext *c = avctx->priv_data;
257

    
258
    dst = frame;
259
    samples = (short *)data;
260
    st= avctx->channels == 2;
261
/*    n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */
262

    
263
    switch(avctx->codec->id) {
264
    case CODEC_ID_ADPCM_IMA_QT: /* XXX: can't test until we get .mov writer */
265
        break;
266
    case CODEC_ID_ADPCM_IMA_WAV:
267
        n = avctx->frame_size / 8;
268
            c->status[0].prev_sample = (signed short)samples[0]; /* XXX */
269
/*            c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */
270
            *dst++ = (c->status[0].prev_sample) & 0xFF; /* little endian */
271
            *dst++ = (c->status[0].prev_sample >> 8) & 0xFF;
272
            *dst++ = (unsigned char)c->status[0].step_index;
273
            *dst++ = 0; /* unknown */
274
            samples++;
275
            if (avctx->channels == 2) {
276
                c->status[1].prev_sample = (signed short)samples[1];
277
/*                c->status[1].step_index = 0; */
278
                *dst++ = (c->status[1].prev_sample) & 0xFF;
279
                *dst++ = (c->status[1].prev_sample >> 8) & 0xFF;
280
                *dst++ = (unsigned char)c->status[1].step_index;
281
                *dst++ = 0;
282
                samples++;
283
            }
284
        
285
            /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */
286
            for (; n>0; n--) {
287
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]) & 0x0F;
288
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4) & 0xF0;
289
                dst++;
290
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]) & 0x0F;
291
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4) & 0xF0;
292
                dst++;
293
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]) & 0x0F;
294
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4) & 0xF0;
295
                dst++;
296
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]) & 0x0F;
297
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4) & 0xF0;
298
                dst++;
299
                /* right channel */
300
                if (avctx->channels == 2) {
301
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]);
302
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4;
303
                    dst++;
304
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]);
305
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4;
306
                    dst++;
307
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]);
308
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;
309
                    dst++;
310
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]);
311
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
312
                    dst++;
313
                }
314
                samples += 8 * avctx->channels;
315
            }
316
        break;
317
    case CODEC_ID_ADPCM_MS:
318
        for(i=0; i<avctx->channels; i++){
319
            int predictor=0;
320

    
321
            *dst++ = predictor;
322
            c->status[i].coeff1 = AdaptCoeff1[predictor];
323
            c->status[i].coeff2 = AdaptCoeff2[predictor];
324
        }
325
        for(i=0; i<avctx->channels; i++){
326
            if (c->status[i].idelta < 16) 
327
                c->status[i].idelta = 16;
328
            
329
            *dst++ = c->status[i].idelta & 0xFF;
330
            *dst++ = c->status[i].idelta >> 8;
331
        }
332
        for(i=0; i<avctx->channels; i++){
333
            c->status[i].sample1= *samples++;
334

    
335
            *dst++ = c->status[i].sample1 & 0xFF;
336
            *dst++ = c->status[i].sample1 >> 8;
337
        }
338
        for(i=0; i<avctx->channels; i++){
339
            c->status[i].sample2= *samples++;
340

    
341
            *dst++ = c->status[i].sample2 & 0xFF;
342
            *dst++ = c->status[i].sample2 >> 8;
343
        }
344

    
345
        for(i=7*avctx->channels; i<avctx->block_align; i++) {
346
            int nibble;
347
            nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4;
348
            nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++);
349
            *dst++ = nibble;
350
        }
351
        break;
352
    default:
353
        return -1;
354
    }
355
    return dst - frame;
356
}
357
#endif //CONFIG_ENCODERS
358

    
359
static int adpcm_decode_init(AVCodecContext * avctx)
360
{
361
    ADPCMContext *c = avctx->priv_data;
362

    
363
    c->channel = 0;
364
    c->status[0].predictor = c->status[1].predictor = 0;
365
    c->status[0].step_index = c->status[1].step_index = 0;
366
    c->status[0].step = c->status[1].step = 0;
367

    
368
    switch(avctx->codec->id) {
369
    case CODEC_ID_ADPCM_CT:
370
        c->status[0].step = c->status[1].step = 511;
371
        break;
372
    default:
373
        break;
374
    }
375
    return 0;
376
}
377

    
378
static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
379
{
380
    int step_index;
381
    int predictor;
382
    int sign, delta, diff, step;
383

    
384
    step = step_table[c->step_index];
385
    step_index = c->step_index + index_table[(unsigned)nibble];
386
    if (step_index < 0) step_index = 0;
387
    else if (step_index > 88) step_index = 88;
388

    
389
    sign = nibble & 8;
390
    delta = nibble & 7;
391
    /* perform direct multiplication instead of series of jumps proposed by
392
     * the reference ADPCM implementation since modern CPUs can do the mults
393
     * quickly enough */
394
    diff = ((2 * delta + 1) * step) >> shift;
395
    predictor = c->predictor;
396
    if (sign) predictor -= diff;
397
    else predictor += diff;
398

    
399
    CLAMP_TO_SHORT(predictor);
400
    c->predictor = predictor;
401
    c->step_index = step_index;
402

    
403
    return (short)predictor;
404
}
405

    
406
static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
407
{
408
    int predictor;
409

    
410
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
411
    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
412
    CLAMP_TO_SHORT(predictor);
413

    
414
    c->sample2 = c->sample1;
415
    c->sample1 = predictor;
416
    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
417
    if (c->idelta < 16) c->idelta = 16;
418

    
419
    return (short)predictor;
420
}
421

    
422
static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
423
{
424
    int predictor;
425
    int sign, delta, diff;
426
    int new_step;
427

    
428
    sign = nibble & 8;
429
    delta = nibble & 7;
430
    /* perform direct multiplication instead of series of jumps proposed by
431
     * the reference ADPCM implementation since modern CPUs can do the mults
432
     * quickly enough */
433
    diff = ((2 * delta + 1) * c->step) >> 3;
434
    predictor = c->predictor;
435
    /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
436
    if(sign)
437
        predictor = ((predictor * 254) >> 8) - diff;
438
    else
439
            predictor = ((predictor * 254) >> 8) + diff;
440
    /* calculate new step and clamp it to range 511..32767 */
441
    new_step = (ct_adpcm_table[nibble & 7] * c->step) >> 8;
442
    c->step = new_step;
443
    if(c->step < 511)
444
        c->step = 511;
445
    if(c->step > 32767)
446
        c->step = 32767;
447

    
448
    CLAMP_TO_SHORT(predictor);
449
    c->predictor = predictor;
450
    return (short)predictor;
451
}
452

    
453
static void xa_decode(short *out, const unsigned char *in, 
454
    ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
455
{
456
    int i, j;
457
    int shift,filter,f0,f1;
458
    int s_1,s_2;
459
    int d,s,t;
460

    
461
    for(i=0;i<4;i++) {
462

    
463
        shift  = 12 - (in[4+i*2] & 15);
464
        filter = in[4+i*2] >> 4;
465
        f0 = xa_adpcm_table[filter][0];
466
        f1 = xa_adpcm_table[filter][1];
467

    
468
        s_1 = left->sample1;
469
        s_2 = left->sample2;
470

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

    
474
            t = (signed char)(d<<4)>>4;
475
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
476
            CLAMP_TO_SHORT(s);
477
            *out = s;
478
            out += inc;
479
            s_2 = s_1;
480
            s_1 = s;
481
        }
482

    
483
        if (inc==2) { /* stereo */
484
            left->sample1 = s_1;
485
            left->sample2 = s_2;
486
            s_1 = right->sample1;
487
            s_2 = right->sample2;
488
            out = out + 1 - 28*2;
489
        }
490

    
491
        shift  = 12 - (in[5+i*2] & 15);
492
        filter = in[5+i*2] >> 4;
493

    
494
        f0 = xa_adpcm_table[filter][0];
495
        f1 = xa_adpcm_table[filter][1];
496

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

    
500
            t = (signed char)d >> 4;
501
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
502
            CLAMP_TO_SHORT(s);
503
            *out = s;
504
            out += inc;
505
            s_2 = s_1;
506
            s_1 = s;
507
        }
508

    
509
        if (inc==2) { /* stereo */
510
            right->sample1 = s_1;
511
            right->sample2 = s_2;
512
            out -= 1;
513
        } else {
514
            left->sample1 = s_1;
515
            left->sample2 = s_2;
516
        }
517
    }
518
}
519

    
520

    
521
/* DK3 ADPCM support macro */
522
#define DK3_GET_NEXT_NIBBLE() \
523
    if (decode_top_nibble_next) \
524
    { \
525
        nibble = (last_byte >> 4) & 0x0F; \
526
        decode_top_nibble_next = 0; \
527
    } \
528
    else \
529
    { \
530
        last_byte = *src++; \
531
        if (src >= buf + buf_size) break; \
532
        nibble = last_byte & 0x0F; \
533
        decode_top_nibble_next = 1; \
534
    }
535

    
536
static int adpcm_decode_frame(AVCodecContext *avctx,
537
                            void *data, int *data_size,
538
                            uint8_t *buf, int buf_size)
539
{
540
    ADPCMContext *c = avctx->priv_data;
541
    ADPCMChannelStatus *cs;
542
    int n, m, channel, i;
543
    int block_predictor[2];
544
    short *samples;
545
    uint8_t *src;
546
    int st; /* stereo */
547

    
548
    /* DK3 ADPCM accounting variables */
549
    unsigned char last_byte = 0;
550
    unsigned char nibble;
551
    int decode_top_nibble_next = 0;
552
    int diff_channel;
553

    
554
    /* EA ADPCM state variables */
555
    uint32_t samples_in_chunk;
556
    int32_t previous_left_sample, previous_right_sample;
557
    int32_t current_left_sample, current_right_sample;
558
    int32_t next_left_sample, next_right_sample;
559
    int32_t coeff1l, coeff2l, coeff1r, coeff2r;
560
    uint8_t shift_left, shift_right;
561
    int count1, count2;
562

    
563
    if (!buf_size)
564
        return 0;
565

    
566
    samples = data;
567
    src = buf;
568

    
569
    st = avctx->channels == 2;
570

    
571
    switch(avctx->codec->id) {
572
    case CODEC_ID_ADPCM_IMA_QT:
573
        n = (buf_size - 2);/* >> 2*avctx->channels;*/
574
        channel = c->channel;
575
        cs = &(c->status[channel]);
576
        /* (pppppp) (piiiiiii) */
577

    
578
        /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
579
        cs->predictor = (*src++) << 8;
580
        cs->predictor |= (*src & 0x80);
581
        cs->predictor &= 0xFF80;
582

    
583
        /* sign extension */
584
        if(cs->predictor & 0x8000)
585
            cs->predictor -= 0x10000;
586

    
587
        CLAMP_TO_SHORT(cs->predictor);
588

    
589
        cs->step_index = (*src++) & 0x7F;
590

    
591
        if (cs->step_index > 88) av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
592
        if (cs->step_index > 88) cs->step_index = 88;
593

    
594
        cs->step = step_table[cs->step_index];
595

    
596
        if (st && channel)
597
            samples++;
598

    
599
        for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
600
            *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3);
601
            samples += avctx->channels;
602
            *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F, 3);
603
            samples += avctx->channels;
604
            src ++;
605
        }
606

    
607
        if(st) { /* handle stereo interlacing */
608
            c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
609
            if(channel == 1) { /* wait for the other packet before outputing anything */
610
                return src - buf;
611
            }
612
        }
613
        break;
614
    case CODEC_ID_ADPCM_IMA_WAV:
615
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
616
            buf_size = avctx->block_align;
617

    
618
        for(i=0; i<avctx->channels; i++){
619
            cs = &(c->status[i]);
620
            cs->predictor = *src++;
621
            cs->predictor |= (*src++) << 8;
622
            if(cs->predictor & 0x8000)
623
                cs->predictor -= 0x10000;
624
            CLAMP_TO_SHORT(cs->predictor);
625

    
626
        // XXX: is this correct ??: *samples++ = cs->predictor;
627

    
628
            cs->step_index = *src++;
629
            if (cs->step_index < 0) cs->step_index = 0;
630
            if (cs->step_index > 88) cs->step_index = 88;
631
            if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null !!\n"); /* unused */
632
        }
633

    
634
        for(m=4; src < (buf + buf_size);) {
635
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F, 3);
636
            if (st)
637
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F, 3);
638
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F, 3);
639
            if (st) {
640
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F, 3);
641
                if (!--m) {
642
                    m=4;
643
                    src+=4;
644
                }
645
            }
646
            src++;
647
        }
648
        break;
649
    case CODEC_ID_ADPCM_4XM:
650
        cs = &(c->status[0]);
651
        c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
652
        if(st){
653
            c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
654
        }
655
        c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
656
        if(st){
657
            c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
658
        }
659
        if (cs->step_index < 0) cs->step_index = 0;
660
        if (cs->step_index > 88) cs->step_index = 88;
661

    
662
        m= (buf_size - (src - buf))>>st;
663
        for(i=0; i<m; i++) {
664
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);
665
            if (st)
666
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);
667
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);
668
            if (st)
669
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);
670
        }
671

    
672
        src += m<<st;
673

    
674
        break;
675
    case CODEC_ID_ADPCM_MS:
676
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
677
            buf_size = avctx->block_align;
678
        n = buf_size - 7 * avctx->channels;
679
        if (n < 0)
680
            return -1;
681
        block_predictor[0] = clip(*src++, 0, 7);
682
        block_predictor[1] = 0;
683
        if (st)
684
            block_predictor[1] = clip(*src++, 0, 7);
685
        c->status[0].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
686
        src+=2;
687
        if (st){
688
            c->status[1].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
689
            src+=2;
690
        }
691
        c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
692
        c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
693
        c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
694
        c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
695
        
696
        c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
697
        src+=2;
698
        if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
699
        if (st) src+=2;
700
        c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
701
        src+=2;
702
        if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
703
        if (st) src+=2;
704

    
705
        *samples++ = c->status[0].sample1;
706
        if (st) *samples++ = c->status[1].sample1;
707
        *samples++ = c->status[0].sample2;
708
        if (st) *samples++ = c->status[1].sample2;
709
        for(;n>0;n--) {
710
            *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
711
            *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
712
            src ++;
713
        }
714
        break;
715
    case CODEC_ID_ADPCM_IMA_DK4:
716
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
717
            buf_size = avctx->block_align;
718

    
719
        c->status[0].predictor = (int16_t)(src[0] | (src[1] << 8));
720
        c->status[0].step_index = src[2];
721
        src += 4;
722
        *samples++ = c->status[0].predictor;
723
        if (st) {
724
            c->status[1].predictor = (int16_t)(src[0] | (src[1] << 8));
725
            c->status[1].step_index = src[2];
726
            src += 4;
727
            *samples++ = c->status[1].predictor;
728
        }
729
        while (src < buf + buf_size) {
730

    
731
            /* take care of the top nibble (always left or mono channel) */
732
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
733
                (src[0] >> 4) & 0x0F, 3);
734

    
735
            /* take care of the bottom nibble, which is right sample for
736
             * stereo, or another mono sample */
737
            if (st)
738
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], 
739
                    src[0] & 0x0F, 3);
740
            else
741
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
742
                    src[0] & 0x0F, 3);
743

    
744
            src++;
745
        }
746
        break;
747
    case CODEC_ID_ADPCM_IMA_DK3:
748
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
749
            buf_size = avctx->block_align;
750

    
751
        c->status[0].predictor = (int16_t)(src[10] | (src[11] << 8));
752
        c->status[1].predictor = (int16_t)(src[12] | (src[13] << 8));
753
        c->status[0].step_index = src[14];
754
        c->status[1].step_index = src[15];
755
        /* sign extend the predictors */
756
        src += 16;
757
        diff_channel = c->status[1].predictor;
758

    
759
        /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
760
         * the buffer is consumed */
761
        while (1) {
762

    
763
            /* for this algorithm, c->status[0] is the sum channel and
764
             * c->status[1] is the diff channel */
765

    
766
            /* process the first predictor of the sum channel */
767
            DK3_GET_NEXT_NIBBLE();
768
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
769

    
770
            /* process the diff channel predictor */
771
            DK3_GET_NEXT_NIBBLE();
772
            adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
773

    
774
            /* process the first pair of stereo PCM samples */
775
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
776
            *samples++ = c->status[0].predictor + c->status[1].predictor;
777
            *samples++ = c->status[0].predictor - c->status[1].predictor;
778

    
779
            /* process the second predictor of the sum channel */
780
            DK3_GET_NEXT_NIBBLE();
781
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
782

    
783
            /* process the second pair of stereo PCM samples */
784
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
785
            *samples++ = c->status[0].predictor + c->status[1].predictor;
786
            *samples++ = c->status[0].predictor - c->status[1].predictor;
787
        }
788
        break;
789
    case CODEC_ID_ADPCM_IMA_WS:
790
        /* no per-block initialization; just start decoding the data */
791
        while (src < buf + buf_size) {
792

    
793
            if (st) {
794
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
795
                    (src[0] >> 4) & 0x0F, 3);
796
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], 
797
                    src[0] & 0x0F, 3);
798
            } else {
799
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
800
                    (src[0] >> 4) & 0x0F, 3);
801
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
802
                    src[0] & 0x0F, 3);
803
            }
804

    
805
            src++;
806
        }
807
        break;
808
    case CODEC_ID_ADPCM_XA:
809
        c->status[0].sample1 = c->status[0].sample2 = 
810
        c->status[1].sample1 = c->status[1].sample2 = 0;
811
        while (buf_size >= 128) {
812
            xa_decode(samples, src, &c->status[0], &c->status[1], 
813
                avctx->channels);
814
            src += 128;
815
            samples += 28 * 8;
816
            buf_size -= 128;
817
        }
818
        break;
819
    case CODEC_ID_ADPCM_EA:
820
        samples_in_chunk = LE_32(src);
821
        if (samples_in_chunk >= ((buf_size - 12) * 2)) {
822
            src += buf_size;
823
            break;
824
        }
825
        src += 4;
826
        current_left_sample = (int16_t)LE_16(src);
827
        src += 2;
828
        previous_left_sample = (int16_t)LE_16(src);
829
        src += 2;
830
        current_right_sample = (int16_t)LE_16(src);
831
        src += 2;
832
        previous_right_sample = (int16_t)LE_16(src);
833
        src += 2;
834

    
835
        for (count1 = 0; count1 < samples_in_chunk/28;count1++) {
836
            coeff1l = ea_adpcm_table[(*src >> 4) & 0x0F];
837
            coeff2l = ea_adpcm_table[((*src >> 4) & 0x0F) + 4];
838
            coeff1r = ea_adpcm_table[*src & 0x0F];
839
            coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
840
            src++;
841

    
842
            shift_left = ((*src >> 4) & 0x0F) + 8;
843
            shift_right = (*src & 0x0F) + 8;
844
            src++;
845

    
846
            for (count2 = 0; count2 < 28; count2++) {
847
                next_left_sample = (((*src & 0xF0) << 24) >> shift_left);
848
                next_right_sample = (((*src & 0x0F) << 28) >> shift_right);
849
                src++;
850

    
851
                next_left_sample = (next_left_sample + 
852
                    (current_left_sample * coeff1l) + 
853
                    (previous_left_sample * coeff2l) + 0x80) >> 8;
854
                next_right_sample = (next_right_sample + 
855
                    (current_right_sample * coeff1r) + 
856
                    (previous_right_sample * coeff2r) + 0x80) >> 8;
857
                CLAMP_TO_SHORT(next_left_sample);
858
                CLAMP_TO_SHORT(next_right_sample);
859

    
860
                previous_left_sample = current_left_sample;
861
                current_left_sample = next_left_sample;
862
                previous_right_sample = current_right_sample;
863
                current_right_sample = next_right_sample;
864
                *samples++ = (unsigned short)current_left_sample;
865
                *samples++ = (unsigned short)current_right_sample;
866
            }
867
        }
868
        break;
869
    case CODEC_ID_ADPCM_IMA_SMJPEG:
870
        c->status[0].predictor = *src;
871
        src += 2;
872
        c->status[0].step_index = *src++;
873
        src++;  /* skip another byte before getting to the meat */
874
        while (src < buf + buf_size) {
875
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
876
                *src & 0x0F, 3);
877
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
878
                (*src >> 4) & 0x0F, 3);
879
            src++;
880
        }
881
        break;
882
    case CODEC_ID_ADPCM_CT:
883
        while (src < buf + buf_size) {
884
            if (st) {
885
                *samples++ = adpcm_ct_expand_nibble(&c->status[0], 
886
                    (src[0] >> 4) & 0x0F);
887
                *samples++ = adpcm_ct_expand_nibble(&c->status[1], 
888
                    src[0] & 0x0F);
889
            } else {
890
                *samples++ = adpcm_ct_expand_nibble(&c->status[0], 
891
                    (src[0] >> 4) & 0x0F);
892
                *samples++ = adpcm_ct_expand_nibble(&c->status[0], 
893
                    src[0] & 0x0F);
894
            }
895
            src++;
896
        }
897
        break;
898
    default:
899
        return -1;
900
    }
901
    *data_size = (uint8_t *)samples - (uint8_t *)data;
902
    return src - buf;
903
}
904

    
905

    
906

    
907
#ifdef CONFIG_ENCODERS
908
#define ADPCM_ENCODER(id,name)                  \
909
AVCodec name ## _encoder = {                    \
910
    #name,                                      \
911
    CODEC_TYPE_AUDIO,                           \
912
    id,                                         \
913
    sizeof(ADPCMContext),                       \
914
    adpcm_encode_init,                          \
915
    adpcm_encode_frame,                         \
916
    adpcm_encode_close,                         \
917
    NULL,                                       \
918
};
919
#else
920
#define ADPCM_ENCODER(id,name)
921
#endif
922

    
923
#ifdef CONFIG_DECODERS
924
#define ADPCM_DECODER(id,name)                  \
925
AVCodec name ## _decoder = {                    \
926
    #name,                                      \
927
    CODEC_TYPE_AUDIO,                           \
928
    id,                                         \
929
    sizeof(ADPCMContext),                       \
930
    adpcm_decode_init,                          \
931
    NULL,                                       \
932
    NULL,                                       \
933
    adpcm_decode_frame,                         \
934
};
935
#else
936
#define ADPCM_DECODER(id,name)
937
#endif
938

    
939
#define ADPCM_CODEC(id, name)                   \
940
ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)
941

    
942
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
943
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
944
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);
945
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);
946
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);
947
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
948
ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
949
ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm);
950
ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa);
951
ADPCM_CODEC(CODEC_ID_ADPCM_ADX, adpcm_adx);
952
ADPCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea);
953
ADPCM_CODEC(CODEC_ID_ADPCM_CT, adpcm_ct);
954

    
955
#undef ADPCM_CODEC