Statistics
| Branch: | Revision:

ffmpeg / libavcodec / adpcm.c @ 11e29a41

History | View | Annotate | Download (26.8 KB)

1 0147f198 François Revol
/*
2
 * ADPCM codecs
3 9937e686 Mike Melanson
 * Copyright (c) 2001-2003 The ffmpeg Project
4 0147f198 François Revol
 *
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 983e3246 Michael Niedermayer
/**
22
 * @file adpcm.c
23
 * ADPCM codecs.
24 fc384777 Mike Melanson
 * First version by Francois Revol (revol@free.fr)
25 2fdf638b Mike Melanson
 * Fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
26 9937e686 Mike Melanson
 *   by Mike Melanson (melanson@pcisys.net)
27 fc384777 Mike Melanson
 * CD-ROM XA ADPCM codec by BERO
28 0147f198 François Revol
 *
29
 * Features and limitations:
30
 *
31
 * Reference documents:
32 9937e686 Mike Melanson
 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html
33 0147f198 François Revol
 * http://www.geocities.com/SiliconValley/8682/aud3.txt
34
 * http://openquicktime.sourceforge.net/plugins.htm
35
 * XAnim sources (xa_codec.c) http://www.rasnaimaging.com/people/lapus/download.html
36 889c5224 François Revol
 * http://www.cs.ucla.edu/~leec/mediabench/applications.html
37
 * SoX source code http://home.sprynet.com/~cbagwell/sox.html
38 fc384777 Mike Melanson
 *
39
 * CD-ROM XA:
40
 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html
41
 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html
42
 * readstr http://www.geocities.co.jp/Playtown/2004/
43 0147f198 François Revol
 */
44
45
#define BLKSIZE 1024
46
47
#define CLAMP_TO_SHORT(value) \
48
if (value > 32767) \
49
    value = 32767; \
50
else if (value < -32768) \
51
    value = -32768; \
52
53
/* step_table[] and index_table[] are from the ADPCM reference source */
54
/* This is the index table: */
55 135ee03a Zdenek Kabelac
static const int index_table[16] = {
56 0147f198 François Revol
    -1, -1, -1, -1, 2, 4, 6, 8,
57
    -1, -1, -1, -1, 2, 4, 6, 8,
58
};
59
60 983e3246 Michael Niedermayer
/** 
61
 * This is the step table. Note that many programs use slight deviations from
62 0147f198 François Revol
 * this table, but such deviations are negligible:
63
 */
64 135ee03a Zdenek Kabelac
static const int step_table[89] = {
65 0147f198 François Revol
    7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
66
    19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
67
    50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
68
    130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
69
    337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
70
    876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
71
    2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
72
    5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
73
    15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
74
};
75
76 fc384777 Mike Melanson
/* These are for MS-ADPCM */
77 0147f198 François Revol
/* AdaptationTable[], AdaptCoeff1[], and AdaptCoeff2[] are from libsndfile */
78 135ee03a Zdenek Kabelac
static const int AdaptationTable[] = {
79 0147f198 François Revol
        230, 230, 230, 230, 307, 409, 512, 614,
80
        768, 614, 512, 409, 307, 230, 230, 230
81
};
82
83 135ee03a Zdenek Kabelac
static const int AdaptCoeff1[] = {
84 0147f198 François Revol
        256, 512, 0, 192, 240, 460, 392
85
};
86
87 135ee03a Zdenek Kabelac
static const int AdaptCoeff2[] = {
88 0147f198 François Revol
        0, -256, 0, 64, 0, -208, -232
89
};
90
91 fc384777 Mike Melanson
/* These are for CD-ROM XA ADPCM */
92 1ffb0091 Alex Beregszaszi
static const int xa_adpcm_table[5][2] = {
93 fc384777 Mike Melanson
   {   0,   0 },
94
   {  60,   0 },
95
   { 115, -52 },
96
   {  98, -55 },
97
   { 122, -60 }
98
};
99
100 0147f198 François Revol
/* end of tables */
101
102
typedef struct ADPCMChannelStatus {
103
    int predictor;
104
    short int step_index;
105
    int step;
106 889c5224 François Revol
    /* for encoding */
107
    int prev_sample;
108 0147f198 François Revol
109
    /* MS version */
110
    short sample1;
111
    short sample2;
112
    int coeff1;
113
    int coeff2;
114
    int idelta;
115
} ADPCMChannelStatus;
116
117
typedef struct ADPCMContext {
118
    int channel; /* for stereo MOVs, decode left, then decode right, then tell it's decoded */
119
    ADPCMChannelStatus status[2];
120
    short sample_buffer[32]; /* hold left samples while waiting for right samples */
121
} ADPCMContext;
122
123
/* XXX: implement encoding */
124
125 764ef400 Mike Melanson
#ifdef CONFIG_ENCODERS
126 0147f198 François Revol
static int adpcm_encode_init(AVCodecContext *avctx)
127
{
128 889c5224 François Revol
    if (avctx->channels > 2)
129
        return -1; /* only stereo or mono =) */
130 0147f198 François Revol
    switch(avctx->codec->id) {
131
    case CODEC_ID_ADPCM_IMA_QT:
132 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "ADPCM: codec admcp_ima_qt unsupported for encoding !\n");
133 889c5224 François Revol
        avctx->frame_size = 64; /* XXX: can multiple of avctx->channels * 64 (left and right blocks are interleaved) */
134
        return -1;
135 0147f198 François Revol
        break;
136
    case CODEC_ID_ADPCM_IMA_WAV:
137 889c5224 François Revol
        avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */
138
                                                             /* and we have 4 bytes per channel overhead */
139
        avctx->block_align = BLKSIZE;
140
        /* seems frame_size isn't taken into account... have to buffer the samples :-( */
141
        break;
142
    case CODEC_ID_ADPCM_MS:
143 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "ADPCM: codec admcp_ms unsupported for encoding !\n");
144 889c5224 François Revol
        return -1;
145 0147f198 François Revol
        break;
146
    default:
147 889c5224 François Revol
        return -1;
148 0147f198 François Revol
        break;
149
    }
150 492cd3a9 Michael Niedermayer
151
    avctx->coded_frame= avcodec_alloc_frame();
152
    avctx->coded_frame->key_frame= 1;
153
154 0147f198 François Revol
    return 0;
155
}
156
157
static int adpcm_encode_close(AVCodecContext *avctx)
158
{
159 492cd3a9 Michael Niedermayer
    av_freep(&avctx->coded_frame);
160
161 0147f198 François Revol
    return 0;
162
}
163
164 889c5224 François Revol
165
static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample)
166
{
167
    int step_index;
168
    unsigned char nibble;
169
    
170
    int sign = 0; /* sign bit of the nibble (MSB) */
171
    int delta, predicted_delta;
172
173
    delta = sample - c->prev_sample;
174
175
    if (delta < 0) {
176
        sign = 1;
177
        delta = -delta;
178
    }
179
180
    step_index = c->step_index;
181
182
    /* nibble = 4 * delta / step_table[step_index]; */
183
    nibble = (delta << 2) / step_table[step_index];
184
185
    if (nibble > 7)
186
        nibble = 7;
187
188
    step_index += index_table[nibble];
189
    if (step_index < 0)
190
        step_index = 0;
191
    if (step_index > 88)
192
        step_index = 88;
193
194
    /* what the decoder will find */
195
    predicted_delta = ((step_table[step_index] * nibble) / 4) + (step_table[step_index] / 8);
196
197
    if (sign)
198
        c->prev_sample -= predicted_delta;
199
    else
200
        c->prev_sample += predicted_delta;
201
202
    CLAMP_TO_SHORT(c->prev_sample);
203
204
205
    nibble += sign << 3; /* sign * 8 */   
206
207
    /* save back */
208
    c->step_index = step_index;
209
210
    return nibble;
211
}
212
213 0147f198 François Revol
static int adpcm_encode_frame(AVCodecContext *avctx,
214
                            unsigned char *frame, int buf_size, void *data)
215
{
216 889c5224 François Revol
    int n;
217 0147f198 François Revol
    short *samples;
218
    unsigned char *dst;
219 889c5224 François Revol
    ADPCMContext *c = avctx->priv_data;
220
221
    dst = frame;
222
    samples = (short *)data;
223
/*    n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */
224 0147f198 François Revol
225
    switch(avctx->codec->id) {
226 889c5224 François Revol
    case CODEC_ID_ADPCM_IMA_QT: /* XXX: can't test until we get .mov writer */
227
        break;
228
    case CODEC_ID_ADPCM_IMA_WAV:
229
        n = avctx->frame_size / 8;
230
            c->status[0].prev_sample = (signed short)samples[0]; /* XXX */
231
/*            c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */
232
            *dst++ = (c->status[0].prev_sample) & 0xFF; /* little endian */
233
            *dst++ = (c->status[0].prev_sample >> 8) & 0xFF;
234
            *dst++ = (unsigned char)c->status[0].step_index;
235
            *dst++ = 0; /* unknown */
236
            samples++;
237
            if (avctx->channels == 2) {
238 1ffb0091 Alex Beregszaszi
                c->status[1].prev_sample = (signed short)samples[1];
239 889c5224 François Revol
/*                c->status[1].step_index = 0; */
240
                *dst++ = (c->status[1].prev_sample) & 0xFF;
241
                *dst++ = (c->status[1].prev_sample >> 8) & 0xFF;
242
                *dst++ = (unsigned char)c->status[1].step_index;
243
                *dst++ = 0;
244
                samples++;
245
            }
246
        
247
            /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */
248
            for (; n>0; n--) {
249
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]) & 0x0F;
250
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4) & 0xF0;
251
                dst++;
252
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]) & 0x0F;
253
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4) & 0xF0;
254
                dst++;
255
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]) & 0x0F;
256
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4) & 0xF0;
257
                dst++;
258
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]) & 0x0F;
259
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4) & 0xF0;
260
                dst++;
261
                /* right channel */
262
                if (avctx->channels == 2) {
263
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]);
264
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4;
265
                    dst++;
266
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]);
267
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4;
268
                    dst++;
269
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]);
270
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;
271
                    dst++;
272
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]);
273
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
274
                    dst++;
275
                }
276
                samples += 8 * avctx->channels;
277
            }
278
        break;
279 0147f198 François Revol
    default:
280
        return -1;
281
    }
282
    return dst - frame;
283
}
284 764ef400 Mike Melanson
#endif //CONFIG_ENCODERS
285 0147f198 François Revol
286
static int adpcm_decode_init(AVCodecContext * avctx)
287
{
288
    ADPCMContext *c = avctx->priv_data;
289
290
    c->channel = 0;
291
    c->status[0].predictor = c->status[1].predictor = 0;
292
    c->status[0].step_index = c->status[1].step_index = 0;
293
    c->status[0].step = c->status[1].step = 0;
294
295
    switch(avctx->codec->id) {
296
    default:
297
        break;
298
    }
299
    return 0;
300
}
301
302
static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble)
303
{
304
    int step_index;
305
    int predictor;
306
    int sign, delta, diff, step;
307
308 135ee03a Zdenek Kabelac
    step = step_table[c->step_index];
309 0147f198 François Revol
    step_index = c->step_index + index_table[(unsigned)nibble];
310
    if (step_index < 0) step_index = 0;
311 135ee03a Zdenek Kabelac
    else if (step_index > 88) step_index = 88;
312 0147f198 François Revol
313
    sign = nibble & 8;
314
    delta = nibble & 7;
315 9937e686 Mike Melanson
    /* perform direct multiplication instead of series of jumps proposed by
316
     * the reference ADPCM implementation since modern CPUs can do the mults
317
     * quickly enough */
318
    diff = ((2 * delta + 1) * step) >> 3;
319 135ee03a Zdenek Kabelac
    predictor = c->predictor;
320 0147f198 François Revol
    if (sign) predictor -= diff;
321
    else predictor += diff;
322
323
    CLAMP_TO_SHORT(predictor);
324
    c->predictor = predictor;
325
    c->step_index = step_index;
326 135ee03a Zdenek Kabelac
327 0147f198 François Revol
    return (short)predictor;
328
}
329
330 4b465299 Michael Niedermayer
static inline short adpcm_4xa_expand_nibble(ADPCMChannelStatus *c, char nibble)
331
{
332
    int step_index;
333
    int predictor;
334
    int sign, delta, diff, step;
335
336
    step = step_table[c->step_index];
337
    step_index = c->step_index + index_table[(unsigned)nibble];
338
    if (step_index < 0) step_index = 0;
339
    else if (step_index > 88) step_index = 88;
340
341
    sign = nibble & 8;
342
    delta = nibble & 7;
343
    
344
    diff = (delta*step + (step>>1))>>3; // difference to code above
345
    
346
    predictor = c->predictor;
347
    if (sign) predictor -= diff;
348
    else predictor += diff;
349
350
    CLAMP_TO_SHORT(predictor);
351
    c->predictor = predictor;
352
    c->step_index = step_index;
353
354
    return (short)predictor;
355
}
356
357 0147f198 François Revol
static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
358
{
359
    int predictor;
360
361
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
362
    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
363
    CLAMP_TO_SHORT(predictor);
364
365
    c->sample2 = c->sample1;
366
    c->sample1 = predictor;
367
    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) / 256;
368
    if (c->idelta < 16) c->idelta = 16;
369
370
    return (short)predictor;
371
}
372
373 fc384777 Mike Melanson
static void xa_decode(short *out, const unsigned char *in, 
374
    ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
375
{
376
    int i, j;
377
    int shift,filter,f0,f1;
378
    int s_1,s_2;
379
    int d,s,t;
380
381
    for(i=0;i<4;i++) {
382
383
        shift  = 12 - (in[4+i*2] & 15);
384
        filter = in[4+i*2] >> 4;
385
        f0 = xa_adpcm_table[filter][0];
386
        f1 = xa_adpcm_table[filter][1];
387
388
        s_1 = left->sample1;
389
        s_2 = left->sample2;
390
391
        for(j=0;j<28;j++) {
392
            d = in[16+i+j*4];
393
394
            t = (signed char)(d<<4)>>4;
395
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
396
            CLAMP_TO_SHORT(s);
397
            *out = s;
398
            out += inc;
399
            s_2 = s_1;
400
            s_1 = s;
401
        }
402
403
        if (inc==2) { /* stereo */
404
            left->sample1 = s_1;
405
            left->sample2 = s_2;
406
            s_1 = right->sample1;
407
            s_2 = right->sample2;
408
            out = out + 1 - 28*2;
409
        }
410
411
        shift  = 12 - (in[5+i*2] & 15);
412
        filter = in[5+i*2] >> 4;
413
414
        f0 = xa_adpcm_table[filter][0];
415
        f1 = xa_adpcm_table[filter][1];
416
417
        for(j=0;j<28;j++) {
418
            d = in[16+i+j*4];
419
420
            t = (signed char)d >> 4;
421
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
422
            CLAMP_TO_SHORT(s);
423
            *out = s;
424
            out += inc;
425
            s_2 = s_1;
426
            s_1 = s;
427
        }
428
429
        if (inc==2) { /* stereo */
430
            right->sample1 = s_1;
431
            right->sample2 = s_2;
432
            out -= 1;
433
        } else {
434
            left->sample1 = s_1;
435
            left->sample2 = s_2;
436
        }
437
    }
438
}
439
440
441 9937e686 Mike Melanson
/* DK3 ADPCM support macro */
442
#define DK3_GET_NEXT_NIBBLE() \
443
    if (decode_top_nibble_next) \
444
    { \
445
        nibble = (last_byte >> 4) & 0x0F; \
446
        decode_top_nibble_next = 0; \
447
    } \
448
    else \
449
    { \
450
        last_byte = *src++; \
451
        if (src >= buf + buf_size) break; \
452
        nibble = last_byte & 0x0F; \
453
        decode_top_nibble_next = 1; \
454
    }
455
456 0147f198 François Revol
static int adpcm_decode_frame(AVCodecContext *avctx,
457
                            void *data, int *data_size,
458 0c1a9eda Zdenek Kabelac
                            uint8_t *buf, int buf_size)
459 0147f198 François Revol
{
460
    ADPCMContext *c = avctx->priv_data;
461
    ADPCMChannelStatus *cs;
462 4b465299 Michael Niedermayer
    int n, m, channel, i;
463 0147f198 François Revol
    int block_predictor[2];
464
    short *samples;
465 0c1a9eda Zdenek Kabelac
    uint8_t *src;
466 0147f198 François Revol
    int st; /* stereo */
467
468 9937e686 Mike Melanson
    /* DK3 ADPCM accounting variables */
469
    unsigned char last_byte = 0;
470
    unsigned char nibble;
471
    int decode_top_nibble_next = 0;
472
    int diff_channel;
473
474 0147f198 François Revol
    samples = data;
475
    src = buf;
476
477
    st = avctx->channels == 2;
478
479
    switch(avctx->codec->id) {
480
    case CODEC_ID_ADPCM_IMA_QT:
481
        n = (buf_size - 2);/* >> 2*avctx->channels;*/
482
        channel = c->channel;
483
        cs = &(c->status[channel]);
484
        /* (pppppp) (piiiiiii) */
485
486
        /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
487
        cs->predictor = (*src++) << 8;
488
        cs->predictor |= (*src & 0x80);
489
        cs->predictor &= 0xFF80;
490
491
        /* sign extension */
492
        if(cs->predictor & 0x8000)
493
            cs->predictor -= 0x10000;
494
495
        CLAMP_TO_SHORT(cs->predictor);
496
497
        cs->step_index = (*src++) & 0x7F;
498
499 9b879566 Michel Bardiaux
        if (cs->step_index > 88) av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
500 0147f198 François Revol
        if (cs->step_index > 88) cs->step_index = 88;
501
502
        cs->step = step_table[cs->step_index];
503
504
        if (st && channel)
505
            samples++;
506
507 889c5224 François Revol
        *samples++ = cs->predictor;
508
        samples += st;
509
510 0147f198 François Revol
        for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
511
            *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F);
512
            samples += avctx->channels;
513
            *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F);
514
            samples += avctx->channels;
515
            src ++;
516
        }
517
518
        if(st) { /* handle stereo interlacing */
519
            c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
520
            if(channel == 0) { /* wait for the other packet before outputing anything */
521
                *data_size = 0;
522
                return src - buf;
523
            }
524
        }
525
        break;
526
    case CODEC_ID_ADPCM_IMA_WAV:
527 ca1d62f4 Assaf Yaari
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
528
            buf_size = avctx->block_align;
529
530 135ee03a Zdenek Kabelac
        // XXX: do as per-channel loop
531 0147f198 François Revol
        cs = &(c->status[0]);
532
        cs->predictor = (*src++) & 0x0FF;
533
        cs->predictor |= ((*src++) << 8) & 0x0FF00;
534
        if(cs->predictor & 0x8000)
535
            cs->predictor -= 0x10000;
536
        CLAMP_TO_SHORT(cs->predictor);
537
538 135ee03a Zdenek Kabelac
        // XXX: is this correct ??: *samples++ = cs->predictor;
539 889c5224 François Revol
540 135ee03a Zdenek Kabelac
        cs->step_index = *src++;
541 0147f198 François Revol
        if (cs->step_index < 0) cs->step_index = 0;
542
        if (cs->step_index > 88) cs->step_index = 88;
543 9b879566 Michel Bardiaux
        if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null !!\n"); /* unused */
544 889c5224 François Revol
545 0147f198 François Revol
        if (st) {
546
            cs = &(c->status[1]);
547
            cs->predictor = (*src++) & 0x0FF;
548
            cs->predictor |= ((*src++) << 8) & 0x0FF00;
549
            if(cs->predictor & 0x8000)
550
                cs->predictor -= 0x10000;
551
            CLAMP_TO_SHORT(cs->predictor);
552
553 135ee03a Zdenek Kabelac
            // XXX: is this correct ??: *samples++ = cs->predictor;
554 889c5224 François Revol
555 135ee03a Zdenek Kabelac
            cs->step_index = *src++;
556 0147f198 François Revol
            if (cs->step_index < 0) cs->step_index = 0;
557
            if (cs->step_index > 88) cs->step_index = 88;
558 135ee03a Zdenek Kabelac
            src++; /* if != 0  -> out-of-sync */
559 0147f198 François Revol
        }
560
561 6b9b85c1 Zdenek Kabelac
        for(m=4; src < (buf + buf_size);) {
562
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F);
563 0147f198 François Revol
            if (st)
564
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F);
565
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
566 6b9b85c1 Zdenek Kabelac
            if (st) {
567 0147f198 François Revol
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F);
568 6b9b85c1 Zdenek Kabelac
                if (!--m) {
569
                    m=4;
570
                    src+=4;
571
                }
572
            }
573
            src++;
574 135ee03a Zdenek Kabelac
        }
575 0147f198 François Revol
        break;
576 4b465299 Michael Niedermayer
    case CODEC_ID_ADPCM_4XM:
577
        cs = &(c->status[0]);
578
        c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
579
        if(st){
580
            c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
581
        }
582
        c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
583
        if(st){
584
            c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
585
        }
586
//            if (cs->step_index < 0) cs->step_index = 0;
587
//            if (cs->step_index > 88) cs->step_index = 88;
588
589
        m= (buf_size - (src - buf))>>st;
590
//printf("%d %d %d %d\n", st, m, c->status[0].predictor, c->status[0].step_index);
591
        //FIXME / XXX decode chanels individual & interleave samples
592
        for(i=0; i<m; i++) {
593
            *samples++ = adpcm_4xa_expand_nibble(&c->status[0], src[i] & 0x0F);
594
            if (st)
595
                *samples++ = adpcm_4xa_expand_nibble(&c->status[1], src[i+m] & 0x0F);
596
            *samples++ = adpcm_4xa_expand_nibble(&c->status[0], src[i] >> 4);
597
            if (st)
598
                *samples++ = adpcm_4xa_expand_nibble(&c->status[1], src[i+m] >> 4);
599
        }
600
601
        src += m<<st;
602
603
        break;
604 0147f198 François Revol
    case CODEC_ID_ADPCM_MS:
605 ca1d62f4 Assaf Yaari
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
606
            buf_size = avctx->block_align;
607 0147f198 François Revol
        n = buf_size - 7 * avctx->channels;
608
        if (n < 0)
609
            return -1;
610
        block_predictor[0] = (*src++); /* should be bound */
611
        block_predictor[0] = (block_predictor[0] < 0)?(0):((block_predictor[0] > 7)?(7):(block_predictor[0]));
612
        block_predictor[1] = 0;
613
        if (st)
614
            block_predictor[1] = (*src++);
615
        block_predictor[1] = (block_predictor[1] < 0)?(0):((block_predictor[1] > 7)?(7):(block_predictor[1]));
616
        c->status[0].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
617
        if (c->status[0].idelta & 0x08000)
618
            c->status[0].idelta -= 0x10000;
619
        src+=2;
620
        if (st)
621
            c->status[1].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
622
        if (st && c->status[1].idelta & 0x08000)
623
            c->status[1].idelta |= 0xFFFF0000;
624
        if (st)
625
            src+=2;
626
        c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
627
        c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
628
        c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
629
        c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
630
        
631
        c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
632
        src+=2;
633
        if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
634
        if (st) src+=2;
635
        c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
636
        src+=2;
637
        if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
638
        if (st) src+=2;
639
640
        *samples++ = c->status[0].sample1;
641
        if (st) *samples++ = c->status[1].sample1;
642
        *samples++ = c->status[0].sample2;
643
        if (st) *samples++ = c->status[1].sample2;
644
        for(;n>0;n--) {
645
            *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
646
            *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
647
            src ++;
648
        }
649
        break;
650 9937e686 Mike Melanson
    case CODEC_ID_ADPCM_IMA_DK4:
651 5c69a4fd Michael Niedermayer
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
652
            buf_size = avctx->block_align;
653
654 9937e686 Mike Melanson
        c->status[0].predictor = (src[0] | (src[1] << 8));
655
        c->status[0].step_index = src[2];
656
        src += 4;
657
        if(c->status[0].predictor & 0x8000)
658
            c->status[0].predictor -= 0x10000;
659
        *samples++ = c->status[0].predictor;
660
        if (st) {
661
            c->status[1].predictor = (src[0] | (src[1] << 8));
662
            c->status[1].step_index = src[2];
663
            src += 4;
664
            if(c->status[1].predictor & 0x8000)
665
                c->status[1].predictor -= 0x10000;
666
            *samples++ = c->status[1].predictor;
667
        }
668
        while (src < buf + buf_size) {
669
670
            /* take care of the top nibble (always left or mono channel) */
671
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
672
                (src[0] >> 4) & 0x0F);
673
674
            /* take care of the bottom nibble, which is right sample for
675
             * stereo, or another mono sample */
676
            if (st)
677
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], 
678
                    src[0] & 0x0F);
679
            else
680
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
681
                    src[0] & 0x0F);
682
683
            src++;
684
        }
685
        break;
686
    case CODEC_ID_ADPCM_IMA_DK3:
687 5c69a4fd Michael Niedermayer
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
688
            buf_size = avctx->block_align;
689
690 9937e686 Mike Melanson
        c->status[0].predictor = (src[10] | (src[11] << 8));
691
        c->status[1].predictor = (src[12] | (src[13] << 8));
692
        c->status[0].step_index = src[14];
693
        c->status[1].step_index = src[15];
694
        /* sign extend the predictors */
695
        if(c->status[0].predictor & 0x8000)
696
            c->status[0].predictor -= 0x10000;
697
        if(c->status[1].predictor & 0x8000)
698
            c->status[1].predictor -= 0x10000;
699
        src += 16;
700
        diff_channel = c->status[1].predictor;
701
702
        /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
703
         * the buffer is consumed */
704
        while (1) {
705
706
            /* for this algorithm, c->status[0] is the sum channel and
707
             * c->status[1] is the diff channel */
708
709
            /* process the first predictor of the sum channel */
710
            DK3_GET_NEXT_NIBBLE();
711
            adpcm_ima_expand_nibble(&c->status[0], nibble);
712
713
            /* process the diff channel predictor */
714
            DK3_GET_NEXT_NIBBLE();
715
            adpcm_ima_expand_nibble(&c->status[1], nibble);
716
717
            /* process the first pair of stereo PCM samples */
718
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
719
            *samples++ = c->status[0].predictor + c->status[1].predictor;
720
            *samples++ = c->status[0].predictor - c->status[1].predictor;
721
722
            /* process the second predictor of the sum channel */
723
            DK3_GET_NEXT_NIBBLE();
724
            adpcm_ima_expand_nibble(&c->status[0], nibble);
725
726
            /* process the second pair of stereo PCM samples */
727
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
728
            *samples++ = c->status[0].predictor + c->status[1].predictor;
729
            *samples++ = c->status[0].predictor - c->status[1].predictor;
730
        }
731
        break;
732 2fdf638b Mike Melanson
    case CODEC_ID_ADPCM_IMA_WS:
733
        /* no per-block initialization; just start decoding the data */
734
        while (src < buf + buf_size) {
735
736
            if (st) {
737
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
738
                    (src[0] >> 4) & 0x0F);
739
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], 
740
                    src[0] & 0x0F);
741
            } else {
742
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
743
                    (src[0] >> 4) & 0x0F);
744
                *samples++ = adpcm_ima_expand_nibble(&c->status[0], 
745
                    src[0] & 0x0F);
746
            }
747
748
            src++;
749
        }
750
        break;
751 fc384777 Mike Melanson
    case CODEC_ID_ADPCM_XA:
752
        c->status[0].sample1 = c->status[0].sample2 = 
753
        c->status[1].sample1 = c->status[1].sample2 = 0;
754
        while (buf_size >= 128) {
755
            xa_decode(samples, src, &c->status[0], &c->status[1], 
756
                avctx->channels);
757
            src += 128;
758
            samples += 28 * 8;
759
            buf_size -= 128;
760
        }
761
        break;
762 0147f198 François Revol
    default:
763
        *data_size = 0;
764
        return -1;
765
    }
766 0c1a9eda Zdenek Kabelac
    *data_size = (uint8_t *)samples - (uint8_t *)data;
767 0147f198 François Revol
    return src - buf;
768
}
769
770 764ef400 Mike Melanson
771
772
#ifdef CONFIG_ENCODERS
773
#define ADPCM_ENCODER(id,name)                  \
774 0147f198 François Revol
AVCodec name ## _encoder = {                    \
775
    #name,                                      \
776
    CODEC_TYPE_AUDIO,                           \
777
    id,                                         \
778
    sizeof(ADPCMContext),                       \
779
    adpcm_encode_init,                          \
780
    adpcm_encode_frame,                         \
781
    adpcm_encode_close,                         \
782
    NULL,                                       \
783 764ef400 Mike Melanson
};
784
#else
785
#define ADPCM_ENCODER(id,name)
786
#endif
787
788
#ifdef CONFIG_DECODERS
789
#define ADPCM_DECODER(id,name)                  \
790 0147f198 François Revol
AVCodec name ## _decoder = {                    \
791
    #name,                                      \
792
    CODEC_TYPE_AUDIO,                           \
793
    id,                                         \
794
    sizeof(ADPCMContext),                       \
795
    adpcm_decode_init,                          \
796
    NULL,                                       \
797
    NULL,                                       \
798
    adpcm_decode_frame,                         \
799
};
800 764ef400 Mike Melanson
#else
801
#define ADPCM_DECODER(id,name)
802
#endif
803
804
#define ADPCM_CODEC(id, name)                   \
805
ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)
806 0147f198 François Revol
807
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
808
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
809 9937e686 Mike Melanson
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);
810
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);
811 2fdf638b Mike Melanson
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);
812 0147f198 François Revol
ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
813 4b465299 Michael Niedermayer
ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm);
814 fc384777 Mike Melanson
ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa);
815
ADPCM_CODEC(CODEC_ID_ADPCM_ADX, adpcm_adx);
816 0147f198 François Revol
817
#undef ADPCM_CODEC