Statistics
| Branch: | Revision:

ffmpeg / libavcodec / adpcm.c @ fe4ff07a

History | View | Annotate | Download (51.3 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 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 0147f198 François Revol
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 0147f198 François Revol
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 0147f198 François Revol
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 0147f198 François Revol
 */
21
#include "avcodec.h"
22 659c3692 Alex Beregszaszi
#include "bitstream.h"
23 949ed6bb Michael Niedermayer
#include "bytestream.h"
24 0147f198 François Revol
25 983e3246 Michael Niedermayer
/**
26
 * @file adpcm.c
27
 * ADPCM codecs.
28 fc384777 Mike Melanson
 * First version by Francois Revol (revol@free.fr)
29 2fdf638b Mike Melanson
 * Fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
30 9937e686 Mike Melanson
 *   by Mike Melanson (melanson@pcisys.net)
31 fc384777 Mike Melanson
 * CD-ROM XA ADPCM codec by BERO
32 7d8379f2 Mike Melanson
 * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com)
33 d1e0d21f Marco Gerards
 * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl)
34 0147f198 François Revol
 *
35
 * Features and limitations:
36
 *
37
 * Reference documents:
38 9937e686 Mike Melanson
 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html
39 0147f198 François Revol
 * http://www.geocities.com/SiliconValley/8682/aud3.txt
40
 * http://openquicktime.sourceforge.net/plugins.htm
41
 * XAnim sources (xa_codec.c) http://www.rasnaimaging.com/people/lapus/download.html
42 889c5224 François Revol
 * http://www.cs.ucla.edu/~leec/mediabench/applications.html
43
 * SoX source code http://home.sprynet.com/~cbagwell/sox.html
44 fc384777 Mike Melanson
 *
45
 * CD-ROM XA:
46
 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html
47
 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html
48
 * readstr http://www.geocities.co.jp/Playtown/2004/
49 0147f198 François Revol
 */
50
51
#define BLKSIZE 1024
52
53
#define CLAMP_TO_SHORT(value) \
54
if (value > 32767) \
55
    value = 32767; \
56
else if (value < -32768) \
57
    value = -32768; \
58
59
/* step_table[] and index_table[] are from the ADPCM reference source */
60
/* This is the index table: */
61 135ee03a Zdenek Kabelac
static const int index_table[16] = {
62 0147f198 François Revol
    -1, -1, -1, -1, 2, 4, 6, 8,
63
    -1, -1, -1, -1, 2, 4, 6, 8,
64
};
65
66 115329f1 Diego Biurrun
/**
67 983e3246 Michael Niedermayer
 * This is the step table. Note that many programs use slight deviations from
68 0147f198 François Revol
 * this table, but such deviations are negligible:
69
 */
70 135ee03a Zdenek Kabelac
static const int step_table[89] = {
71 0147f198 François Revol
    7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
72
    19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
73
    50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
74
    130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
75
    337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
76
    876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
77
    2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
78
    5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
79
    15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
80
};
81
82 fc384777 Mike Melanson
/* These are for MS-ADPCM */
83 0147f198 François Revol
/* AdaptationTable[], AdaptCoeff1[], and AdaptCoeff2[] are from libsndfile */
84 135ee03a Zdenek Kabelac
static const int AdaptationTable[] = {
85 0147f198 François Revol
        230, 230, 230, 230, 307, 409, 512, 614,
86
        768, 614, 512, 409, 307, 230, 230, 230
87
};
88
89 135ee03a Zdenek Kabelac
static const int AdaptCoeff1[] = {
90 0147f198 François Revol
        256, 512, 0, 192, 240, 460, 392
91
};
92
93 135ee03a Zdenek Kabelac
static const int AdaptCoeff2[] = {
94 0147f198 François Revol
        0, -256, 0, 64, 0, -208, -232
95
};
96
97 fc384777 Mike Melanson
/* These are for CD-ROM XA ADPCM */
98 1ffb0091 Alex Beregszaszi
static const int xa_adpcm_table[5][2] = {
99 fc384777 Mike Melanson
   {   0,   0 },
100
   {  60,   0 },
101
   { 115, -52 },
102
   {  98, -55 },
103
   { 122, -60 }
104
};
105
106 c26ae41d Michael Niedermayer
static const int ea_adpcm_table[] = {
107 7d8379f2 Mike Melanson
    0, 240, 460, 392, 0, 0, -208, -220, 0, 1,
108
    3, 4, 7, 8, 10, 11, 0, -1, -3, -4
109
};
110
111 c26ae41d Michael Niedermayer
static const int ct_adpcm_table[8] = {
112 b3bfb299 Mike Melanson
    0x00E6, 0x00E6, 0x00E6, 0x00E6,
113
    0x0133, 0x0199, 0x0200, 0x0266
114
};
115
116 659c3692 Alex Beregszaszi
// padded to zero where table size is less then 16
117 c26ae41d Michael Niedermayer
static const int swf_index_tables[4][16] = {
118 659c3692 Alex Beregszaszi
    /*2*/ { -1, 2 },
119
    /*3*/ { -1, -1, 2, 4 },
120
    /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },
121
    /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
122
};
123
124 2ff4524e Vidar Madsen
static const int yamaha_indexscale[] = {
125
    230, 230, 230, 230, 307, 409, 512, 614,
126
    230, 230, 230, 230, 307, 409, 512, 614
127
};
128
129
static const int yamaha_difflookup[] = {
130
    1, 3, 5, 7, 9, 11, 13, 15,
131
    -1, -3, -5, -7, -9, -11, -13, -15
132
};
133
134 0147f198 François Revol
/* end of tables */
135
136
typedef struct ADPCMChannelStatus {
137
    int predictor;
138
    short int step_index;
139
    int step;
140 889c5224 François Revol
    /* for encoding */
141
    int prev_sample;
142 0147f198 François Revol
143
    /* MS version */
144
    short sample1;
145
    short sample2;
146
    int coeff1;
147
    int coeff2;
148
    int idelta;
149
} ADPCMChannelStatus;
150
151
typedef struct ADPCMContext {
152
    int channel; /* for stereo MOVs, decode left, then decode right, then tell it's decoded */
153
    ADPCMChannelStatus status[2];
154
    short sample_buffer[32]; /* hold left samples while waiting for right samples */
155
} ADPCMContext;
156
157
/* XXX: implement encoding */
158
159 764ef400 Mike Melanson
#ifdef CONFIG_ENCODERS
160 0147f198 François Revol
static int adpcm_encode_init(AVCodecContext *avctx)
161
{
162 889c5224 François Revol
    if (avctx->channels > 2)
163
        return -1; /* only stereo or mono =) */
164 0147f198 François Revol
    switch(avctx->codec->id) {
165
    case CODEC_ID_ADPCM_IMA_QT:
166 8dbcc9f2 Fabrice Bellard
        av_log(avctx, AV_LOG_ERROR, "ADPCM: codec adpcm_ima_qt unsupported for encoding !\n");
167 889c5224 François Revol
        avctx->frame_size = 64; /* XXX: can multiple of avctx->channels * 64 (left and right blocks are interleaved) */
168
        return -1;
169 0147f198 François Revol
        break;
170
    case CODEC_ID_ADPCM_IMA_WAV:
171 889c5224 François Revol
        avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */
172
                                                             /* and we have 4 bytes per channel overhead */
173
        avctx->block_align = BLKSIZE;
174
        /* seems frame_size isn't taken into account... have to buffer the samples :-( */
175
        break;
176
    case CODEC_ID_ADPCM_MS:
177 6cf9d5eb Michael Niedermayer
        avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */
178
                                                             /* and we have 7 bytes per channel overhead */
179
        avctx->block_align = BLKSIZE;
180 0147f198 François Revol
        break;
181 2ff4524e Vidar Madsen
    case CODEC_ID_ADPCM_YAMAHA:
182
        avctx->frame_size = BLKSIZE * avctx->channels;
183
        avctx->block_align = BLKSIZE;
184
        break;
185 d64b88d4 Benjamin Larsson
    case CODEC_ID_ADPCM_SWF:
186 9fff16bc Baptiste Coudurier
        if (avctx->sample_rate != 11025 &&
187
            avctx->sample_rate != 22050 &&
188
            avctx->sample_rate != 44100) {
189
            av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, 22050 or 44100\n");
190
            return -1;
191
        }
192
        avctx->frame_size = 512 * (avctx->sample_rate / 11025);
193 d64b88d4 Benjamin Larsson
        break;
194 0147f198 François Revol
    default:
195 889c5224 François Revol
        return -1;
196 0147f198 François Revol
        break;
197
    }
198 492cd3a9 Michael Niedermayer
199
    avctx->coded_frame= avcodec_alloc_frame();
200
    avctx->coded_frame->key_frame= 1;
201
202 0147f198 François Revol
    return 0;
203
}
204
205
static int adpcm_encode_close(AVCodecContext *avctx)
206
{
207 492cd3a9 Michael Niedermayer
    av_freep(&avctx->coded_frame);
208
209 0147f198 François Revol
    return 0;
210
}
211
212 889c5224 François Revol
213
static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample)
214
{
215 7e537051 Loren Merritt
    int delta = sample - c->prev_sample;
216
    int nibble = FFMIN(7, abs(delta)*4/step_table[c->step_index]) + (delta<0)*8;
217
    c->prev_sample = c->prev_sample + ((step_table[c->step_index] * yamaha_difflookup[nibble]) / 8);
218 889c5224 François Revol
    CLAMP_TO_SHORT(c->prev_sample);
219 f66e4f5f Reimar Döffinger
    c->step_index = av_clip(c->step_index + index_table[nibble], 0, 88);
220 889c5224 François Revol
    return nibble;
221
}
222
223 6cf9d5eb Michael Niedermayer
static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample)
224
{
225
    int predictor, nibble, bias;
226
227
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
228 115329f1 Diego Biurrun
229 6cf9d5eb Michael Niedermayer
    nibble= sample - predictor;
230
    if(nibble>=0) bias= c->idelta/2;
231
    else          bias=-c->idelta/2;
232 115329f1 Diego Biurrun
233 6cf9d5eb Michael Niedermayer
    nibble= (nibble + bias) / c->idelta;
234 f66e4f5f Reimar Döffinger
    nibble= av_clip(nibble, -8, 7)&0x0F;
235 115329f1 Diego Biurrun
236 6cf9d5eb Michael Niedermayer
    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
237
    CLAMP_TO_SHORT(predictor);
238
239
    c->sample2 = c->sample1;
240
    c->sample1 = predictor;
241
242
    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
243
    if (c->idelta < 16) c->idelta = 16;
244
245
    return nibble;
246
}
247
248 2ff4524e Vidar Madsen
static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, short sample)
249
{
250 7e537051 Loren Merritt
    int nibble, delta;
251 2ff4524e Vidar Madsen
252
    if(!c->step) {
253
        c->predictor = 0;
254
        c->step = 127;
255
    }
256
257 7e537051 Loren Merritt
    delta = sample - c->predictor;
258 2ff4524e Vidar Madsen
259 7e537051 Loren Merritt
    nibble = FFMIN(7, abs(delta)*4/c->step) + (delta<0)*8;
260
261
    c->predictor = c->predictor + ((c->step * yamaha_difflookup[nibble]) / 8);
262 2ff4524e Vidar Madsen
    CLAMP_TO_SHORT(c->predictor);
263 7e537051 Loren Merritt
    c->step = (c->step * yamaha_indexscale[nibble]) >> 8;
264 f66e4f5f Reimar Döffinger
    c->step = av_clip(c->step, 127, 24567);
265 2ff4524e Vidar Madsen
266 7e537051 Loren Merritt
    return nibble;
267 2ff4524e Vidar Madsen
}
268
269 696d6889 Loren Merritt
typedef struct TrellisPath {
270
    int nibble;
271
    int prev;
272
} TrellisPath;
273
274
typedef struct TrellisNode {
275
    uint32_t ssd;
276
    int path;
277
    int sample1;
278
    int sample2;
279
    int step;
280
} TrellisNode;
281
282
static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
283
                                   uint8_t *dst, ADPCMChannelStatus *c, int n)
284
{
285
#define FREEZE_INTERVAL 128
286
    //FIXME 6% faster if frontier is a compile-time constant
287
    const int frontier = 1 << avctx->trellis;
288
    const int stride = avctx->channels;
289
    const int version = avctx->codec->id;
290
    const int max_paths = frontier*FREEZE_INTERVAL;
291
    TrellisPath paths[max_paths], *p;
292
    TrellisNode node_buf[2][frontier];
293
    TrellisNode *nodep_buf[2][frontier];
294
    TrellisNode **nodes = nodep_buf[0]; // nodes[] is always sorted by .ssd
295
    TrellisNode **nodes_next = nodep_buf[1];
296
    int pathn = 0, froze = -1, i, j, k;
297
298
    assert(!(max_paths&(max_paths-1)));
299
300
    memset(nodep_buf, 0, sizeof(nodep_buf));
301
    nodes[0] = &node_buf[1][0];
302
    nodes[0]->ssd = 0;
303
    nodes[0]->path = 0;
304
    nodes[0]->step = c->step_index;
305
    nodes[0]->sample1 = c->sample1;
306
    nodes[0]->sample2 = c->sample2;
307
    if(version == CODEC_ID_ADPCM_IMA_WAV)
308
        nodes[0]->sample1 = c->prev_sample;
309
    if(version == CODEC_ID_ADPCM_MS)
310
        nodes[0]->step = c->idelta;
311
    if(version == CODEC_ID_ADPCM_YAMAHA) {
312
        if(c->step == 0) {
313
            nodes[0]->step = 127;
314
            nodes[0]->sample1 = 0;
315
        } else {
316
            nodes[0]->step = c->step;
317
            nodes[0]->sample1 = c->predictor;
318
        }
319
    }
320
321
    for(i=0; i<n; i++) {
322
        TrellisNode *t = node_buf[i&1];
323
        TrellisNode **u;
324
        int sample = samples[i*stride];
325
        memset(nodes_next, 0, frontier*sizeof(TrellisNode*));
326
        for(j=0; j<frontier && nodes[j]; j++) {
327
            // higher j have higher ssd already, so they're unlikely to use a suboptimal next sample too
328
            const int range = (j < frontier/2) ? 1 : 0;
329
            const int step = nodes[j]->step;
330
            int nidx;
331
            if(version == CODEC_ID_ADPCM_MS) {
332
                const int predictor = ((nodes[j]->sample1 * c->coeff1) + (nodes[j]->sample2 * c->coeff2)) / 256;
333
                const int div = (sample - predictor) / step;
334 f66e4f5f Reimar Döffinger
                const int nmin = av_clip(div-range, -8, 6);
335
                const int nmax = av_clip(div+range, -7, 7);
336 696d6889 Loren Merritt
                for(nidx=nmin; nidx<=nmax; nidx++) {
337
                    const int nibble = nidx & 0xf;
338
                    int dec_sample = predictor + nidx * step;
339
#define STORE_NODE(NAME, STEP_INDEX)\
340
                    int d;\
341
                    uint32_t ssd;\
342
                    CLAMP_TO_SHORT(dec_sample);\
343
                    d = sample - dec_sample;\
344
                    ssd = nodes[j]->ssd + d*d;\
345
                    if(nodes_next[frontier-1] && ssd >= nodes_next[frontier-1]->ssd)\
346
                        continue;\
347
                    /* Collapse any two states with the same previous sample value. \
348
                     * One could also distinguish states by step and by 2nd to last
349
                     * sample, but the effects of that are negligible. */\
350
                    for(k=0; k<frontier && nodes_next[k]; k++) {\
351
                        if(dec_sample == nodes_next[k]->sample1) {\
352
                            assert(ssd >= nodes_next[k]->ssd);\
353
                            goto next_##NAME;\
354
                        }\
355
                    }\
356
                    for(k=0; k<frontier; k++) {\
357
                        if(!nodes_next[k] || ssd < nodes_next[k]->ssd) {\
358
                            TrellisNode *u = nodes_next[frontier-1];\
359
                            if(!u) {\
360
                                assert(pathn < max_paths);\
361
                                u = t++;\
362
                                u->path = pathn++;\
363
                            }\
364
                            u->ssd = ssd;\
365
                            u->step = STEP_INDEX;\
366
                            u->sample2 = nodes[j]->sample1;\
367
                            u->sample1 = dec_sample;\
368
                            paths[u->path].nibble = nibble;\
369
                            paths[u->path].prev = nodes[j]->path;\
370
                            memmove(&nodes_next[k+1], &nodes_next[k], (frontier-k-1)*sizeof(TrellisNode*));\
371
                            nodes_next[k] = u;\
372
                            break;\
373
                        }\
374
                    }\
375
                    next_##NAME:;
376
                    STORE_NODE(ms, FFMAX(16, (AdaptationTable[nibble] * step) >> 8));
377
                }
378
            } else if(version == CODEC_ID_ADPCM_IMA_WAV) {
379
#define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
380
                const int predictor = nodes[j]->sample1;\
381
                const int div = (sample - predictor) * 4 / STEP_TABLE;\
382 f66e4f5f Reimar Döffinger
                int nmin = av_clip(div-range, -7, 6);\
383
                int nmax = av_clip(div+range, -6, 7);\
384 696d6889 Loren Merritt
                if(nmin<=0) nmin--; /* distinguish -0 from +0 */\
385
                if(nmax<0) nmax--;\
386
                for(nidx=nmin; nidx<=nmax; nidx++) {\
387
                    const int nibble = nidx<0 ? 7-nidx : nidx;\
388
                    int dec_sample = predictor + (STEP_TABLE * yamaha_difflookup[nibble]) / 8;\
389
                    STORE_NODE(NAME, STEP_INDEX);\
390
                }
391 f66e4f5f Reimar Döffinger
                LOOP_NODES(ima, step_table[step], av_clip(step + index_table[nibble], 0, 88));
392 696d6889 Loren Merritt
            } else { //CODEC_ID_ADPCM_YAMAHA
393 f66e4f5f Reimar Döffinger
                LOOP_NODES(yamaha, step, av_clip((step * yamaha_indexscale[nibble]) >> 8, 127, 24567));
394 696d6889 Loren Merritt
#undef LOOP_NODES
395
#undef STORE_NODE
396
            }
397
        }
398
399
        u = nodes;
400
        nodes = nodes_next;
401
        nodes_next = u;
402
403
        // prevent overflow
404
        if(nodes[0]->ssd > (1<<28)) {
405
            for(j=1; j<frontier && nodes[j]; j++)
406
                nodes[j]->ssd -= nodes[0]->ssd;
407
            nodes[0]->ssd = 0;
408
        }
409
410
        // merge old paths to save memory
411
        if(i == froze + FREEZE_INTERVAL) {
412
            p = &paths[nodes[0]->path];
413
            for(k=i; k>froze; k--) {
414
                dst[k] = p->nibble;
415
                p = &paths[p->prev];
416
            }
417
            froze = i;
418
            pathn = 0;
419
            // other nodes might use paths that don't coincide with the frozen one.
420
            // checking which nodes do so is too slow, so just kill them all.
421
            // this also slightly improves quality, but I don't know why.
422
            memset(nodes+1, 0, (frontier-1)*sizeof(TrellisNode*));
423
        }
424
    }
425
426
    p = &paths[nodes[0]->path];
427
    for(i=n-1; i>froze; i--) {
428
        dst[i] = p->nibble;
429
        p = &paths[p->prev];
430
    }
431
432
    c->predictor = nodes[0]->sample1;
433
    c->sample1 = nodes[0]->sample1;
434
    c->sample2 = nodes[0]->sample2;
435
    c->step_index = nodes[0]->step;
436
    c->step = nodes[0]->step;
437
    c->idelta = nodes[0]->step;
438
}
439
440 0147f198 François Revol
static int adpcm_encode_frame(AVCodecContext *avctx,
441 bb270c08 Diego Biurrun
                            unsigned char *frame, int buf_size, void *data)
442 0147f198 François Revol
{
443 6cf9d5eb Michael Niedermayer
    int n, i, st;
444 0147f198 François Revol
    short *samples;
445
    unsigned char *dst;
446 889c5224 François Revol
    ADPCMContext *c = avctx->priv_data;
447
448
    dst = frame;
449
    samples = (short *)data;
450 6cf9d5eb Michael Niedermayer
    st= avctx->channels == 2;
451 889c5224 François Revol
/*    n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */
452 0147f198 François Revol
453
    switch(avctx->codec->id) {
454 889c5224 François Revol
    case CODEC_ID_ADPCM_IMA_QT: /* XXX: can't test until we get .mov writer */
455
        break;
456
    case CODEC_ID_ADPCM_IMA_WAV:
457
        n = avctx->frame_size / 8;
458
            c->status[0].prev_sample = (signed short)samples[0]; /* XXX */
459
/*            c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */
460 2c124cb6 Ramiro Polla
            bytestream_put_le16(&dst, c->status[0].prev_sample);
461 889c5224 François Revol
            *dst++ = (unsigned char)c->status[0].step_index;
462
            *dst++ = 0; /* unknown */
463
            samples++;
464
            if (avctx->channels == 2) {
465 1ffb0091 Alex Beregszaszi
                c->status[1].prev_sample = (signed short)samples[1];
466 889c5224 François Revol
/*                c->status[1].step_index = 0; */
467 2c124cb6 Ramiro Polla
                bytestream_put_le16(&dst, c->status[1].prev_sample);
468 889c5224 François Revol
                *dst++ = (unsigned char)c->status[1].step_index;
469
                *dst++ = 0;
470
                samples++;
471
            }
472 115329f1 Diego Biurrun
473 889c5224 François Revol
            /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */
474 696d6889 Loren Merritt
            if(avctx->trellis > 0) {
475
                uint8_t buf[2][n*8];
476
                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n*8);
477
                if(avctx->channels == 2)
478
                    adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n*8);
479
                for(i=0; i<n; i++) {
480
                    *dst++ = buf[0][8*i+0] | (buf[0][8*i+1] << 4);
481
                    *dst++ = buf[0][8*i+2] | (buf[0][8*i+3] << 4);
482
                    *dst++ = buf[0][8*i+4] | (buf[0][8*i+5] << 4);
483
                    *dst++ = buf[0][8*i+6] | (buf[0][8*i+7] << 4);
484
                    if (avctx->channels == 2) {
485
                        *dst++ = buf[1][8*i+0] | (buf[1][8*i+1] << 4);
486
                        *dst++ = buf[1][8*i+2] | (buf[1][8*i+3] << 4);
487
                        *dst++ = buf[1][8*i+4] | (buf[1][8*i+5] << 4);
488
                        *dst++ = buf[1][8*i+6] | (buf[1][8*i+7] << 4);
489
                    }
490
                }
491
            } else
492 889c5224 François Revol
            for (; n>0; n--) {
493
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]) & 0x0F;
494
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4) & 0xF0;
495
                dst++;
496
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]) & 0x0F;
497
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4) & 0xF0;
498
                dst++;
499
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]) & 0x0F;
500
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4) & 0xF0;
501
                dst++;
502
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]) & 0x0F;
503
                *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4) & 0xF0;
504
                dst++;
505
                /* right channel */
506
                if (avctx->channels == 2) {
507
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]);
508
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4;
509
                    dst++;
510
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]);
511
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4;
512
                    dst++;
513
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]);
514
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;
515
                    dst++;
516
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]);
517
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
518
                    dst++;
519
                }
520
                samples += 8 * avctx->channels;
521
            }
522
        break;
523 d64b88d4 Benjamin Larsson
    case CODEC_ID_ADPCM_SWF:
524
    {
525
        int i;
526
        PutBitContext pb;
527
        init_put_bits(&pb, dst, buf_size*8);
528
529
        //Store AdpcmCodeSize
530
        put_bits(&pb, 2, 2);                //Set 4bits flash adpcm format
531
532
        //Init the encoder state
533
        for(i=0; i<avctx->channels; i++){
534 ac069107 Baptiste Coudurier
            c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63); // clip step so it fits 6 bits
535 d64b88d4 Benjamin Larsson
            put_bits(&pb, 16, samples[i] & 0xFFFF);
536 ac069107 Baptiste Coudurier
            put_bits(&pb, 6, c->status[i].step_index);
537 d64b88d4 Benjamin Larsson
            c->status[i].prev_sample = (signed short)samples[i];
538
        }
539
540 9fff16bc Baptiste Coudurier
        for (i=0; i<avctx->frame_size; i++) {
541 d64b88d4 Benjamin Larsson
            put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i]) & 0xF);
542
            if (avctx->channels == 2)
543
                put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1]) & 0xF);
544
        }
545 9fff16bc Baptiste Coudurier
        flush_put_bits(&pb);
546
        dst += put_bits_count(&pb)>>3;
547 d64b88d4 Benjamin Larsson
        break;
548
    }
549 6cf9d5eb Michael Niedermayer
    case CODEC_ID_ADPCM_MS:
550
        for(i=0; i<avctx->channels; i++){
551
            int predictor=0;
552
553
            *dst++ = predictor;
554
            c->status[i].coeff1 = AdaptCoeff1[predictor];
555
            c->status[i].coeff2 = AdaptCoeff2[predictor];
556
        }
557
        for(i=0; i<avctx->channels; i++){
558 115329f1 Diego Biurrun
            if (c->status[i].idelta < 16)
559 6cf9d5eb Michael Niedermayer
                c->status[i].idelta = 16;
560 115329f1 Diego Biurrun
561 2c124cb6 Ramiro Polla
            bytestream_put_le16(&dst, c->status[i].idelta);
562 6cf9d5eb Michael Niedermayer
        }
563
        for(i=0; i<avctx->channels; i++){
564
            c->status[i].sample1= *samples++;
565
566 2c124cb6 Ramiro Polla
            bytestream_put_le16(&dst, c->status[i].sample1);
567 6cf9d5eb Michael Niedermayer
        }
568
        for(i=0; i<avctx->channels; i++){
569
            c->status[i].sample2= *samples++;
570
571 2c124cb6 Ramiro Polla
            bytestream_put_le16(&dst, c->status[i].sample2);
572 6cf9d5eb Michael Niedermayer
        }
573
574 696d6889 Loren Merritt
        if(avctx->trellis > 0) {
575
            int n = avctx->block_align - 7*avctx->channels;
576
            uint8_t buf[2][n];
577
            if(avctx->channels == 1) {
578
                n *= 2;
579
                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
580
                for(i=0; i<n; i+=2)
581
                    *dst++ = (buf[0][i] << 4) | buf[0][i+1];
582
            } else {
583
                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
584
                adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
585
                for(i=0; i<n; i++)
586
                    *dst++ = (buf[0][i] << 4) | buf[1][i];
587
            }
588
        } else
589 6cf9d5eb Michael Niedermayer
        for(i=7*avctx->channels; i<avctx->block_align; i++) {
590
            int nibble;
591
            nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4;
592
            nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++);
593
            *dst++ = nibble;
594
        }
595
        break;
596 2ff4524e Vidar Madsen
    case CODEC_ID_ADPCM_YAMAHA:
597
        n = avctx->frame_size / 2;
598 696d6889 Loren Merritt
        if(avctx->trellis > 0) {
599
            uint8_t buf[2][n*2];
600
            n *= 2;
601
            if(avctx->channels == 1) {
602
                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
603
                for(i=0; i<n; i+=2)
604
                    *dst++ = buf[0][i] | (buf[0][i+1] << 4);
605
            } else {
606
                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
607
                adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
608
                for(i=0; i<n; i++)
609
                    *dst++ = buf[0][i] | (buf[1][i] << 4);
610
            }
611
        } else
612 2ff4524e Vidar Madsen
        for (; n>0; n--) {
613
            for(i = 0; i < avctx->channels; i++) {
614
                int nibble;
615 b194c327 Michael Niedermayer
                nibble  = adpcm_yamaha_compress_sample(&c->status[i], samples[i]);
616
                nibble |= adpcm_yamaha_compress_sample(&c->status[i], samples[i+avctx->channels]) << 4;
617 2ff4524e Vidar Madsen
                *dst++ = nibble;
618
            }
619
            samples += 2 * avctx->channels;
620
        }
621
        break;
622 0147f198 François Revol
    default:
623
        return -1;
624
    }
625
    return dst - frame;
626
}
627 764ef400 Mike Melanson
#endif //CONFIG_ENCODERS
628 0147f198 François Revol
629
static int adpcm_decode_init(AVCodecContext * avctx)
630
{
631
    ADPCMContext *c = avctx->priv_data;
632
633 14c49573 Michael Niedermayer
    if(avctx->channels > 2U){
634
        return -1;
635
    }
636
637 0147f198 François Revol
    c->channel = 0;
638
    c->status[0].predictor = c->status[1].predictor = 0;
639
    c->status[0].step_index = c->status[1].step_index = 0;
640
    c->status[0].step = c->status[1].step = 0;
641
642
    switch(avctx->codec->id) {
643 b3bfb299 Mike Melanson
    case CODEC_ID_ADPCM_CT:
644 bb270c08 Diego Biurrun
        c->status[0].step = c->status[1].step = 511;
645
        break;
646 8e952e4d Anssi Hannula
    case CODEC_ID_ADPCM_IMA_WS:
647
        if (avctx->extradata && avctx->extradata_size == 2 * 4) {
648
            c->status[0].predictor = AV_RL32(avctx->extradata);
649
            c->status[1].predictor = AV_RL32(avctx->extradata + 4);
650
        }
651
        break;
652 0147f198 François Revol
    default:
653
        break;
654
    }
655
    return 0;
656
}
657
658 d94728c3 Michael Niedermayer
static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
659 0147f198 François Revol
{
660
    int step_index;
661
    int predictor;
662
    int sign, delta, diff, step;
663
664 135ee03a Zdenek Kabelac
    step = step_table[c->step_index];
665 0147f198 François Revol
    step_index = c->step_index + index_table[(unsigned)nibble];
666
    if (step_index < 0) step_index = 0;
667 135ee03a Zdenek Kabelac
    else if (step_index > 88) step_index = 88;
668 0147f198 François Revol
669
    sign = nibble & 8;
670
    delta = nibble & 7;
671 9937e686 Mike Melanson
    /* perform direct multiplication instead of series of jumps proposed by
672
     * the reference ADPCM implementation since modern CPUs can do the mults
673
     * quickly enough */
674 d94728c3 Michael Niedermayer
    diff = ((2 * delta + 1) * step) >> shift;
675 4b465299 Michael Niedermayer
    predictor = c->predictor;
676
    if (sign) predictor -= diff;
677
    else predictor += diff;
678
679
    CLAMP_TO_SHORT(predictor);
680
    c->predictor = predictor;
681
    c->step_index = step_index;
682
683
    return (short)predictor;
684
}
685
686 0147f198 François Revol
static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
687
{
688
    int predictor;
689
690
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
691
    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
692
    CLAMP_TO_SHORT(predictor);
693
694
    c->sample2 = c->sample1;
695
    c->sample1 = predictor;
696 6cf9d5eb Michael Niedermayer
    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
697 0147f198 François Revol
    if (c->idelta < 16) c->idelta = 16;
698
699
    return (short)predictor;
700
}
701
702 b3bfb299 Mike Melanson
static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
703
{
704
    int predictor;
705
    int sign, delta, diff;
706
    int new_step;
707
708
    sign = nibble & 8;
709
    delta = nibble & 7;
710
    /* perform direct multiplication instead of series of jumps proposed by
711
     * the reference ADPCM implementation since modern CPUs can do the mults
712
     * quickly enough */
713
    diff = ((2 * delta + 1) * c->step) >> 3;
714
    predictor = c->predictor;
715
    /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
716
    if(sign)
717 bb270c08 Diego Biurrun
        predictor = ((predictor * 254) >> 8) - diff;
718 b3bfb299 Mike Melanson
    else
719 bb270c08 Diego Biurrun
            predictor = ((predictor * 254) >> 8) + diff;
720 b3bfb299 Mike Melanson
    /* calculate new step and clamp it to range 511..32767 */
721
    new_step = (ct_adpcm_table[nibble & 7] * c->step) >> 8;
722
    c->step = new_step;
723
    if(c->step < 511)
724 bb270c08 Diego Biurrun
        c->step = 511;
725 b3bfb299 Mike Melanson
    if(c->step > 32767)
726 bb270c08 Diego Biurrun
        c->step = 32767;
727 b3bfb299 Mike Melanson
728
    CLAMP_TO_SHORT(predictor);
729
    c->predictor = predictor;
730
    return (short)predictor;
731
}
732
733 2433f24f Aurelien Jacobs
static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
734
{
735
    int sign, delta, diff;
736
737
    sign = nibble & (1<<(size-1));
738
    delta = nibble & ((1<<(size-1))-1);
739
    diff = delta << (7 + c->step + shift);
740
741
    if (sign)
742
        c->predictor -= diff;
743
    else
744
        c->predictor += diff;
745
746
    /* clamp result */
747
    if (c->predictor > 16256)
748
        c->predictor = 16256;
749
    else if (c->predictor < -16384)
750
        c->predictor = -16384;
751
752
    /* calculate new step */
753
    if (delta >= (2*size - 3) && c->step < 3)
754
        c->step++;
755
    else if (delta == 0 && c->step > 0)
756
        c->step--;
757
758
    return (short) c->predictor;
759
}
760
761 2ff4524e Vidar Madsen
static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
762
{
763
    if(!c->step) {
764
        c->predictor = 0;
765
        c->step = 127;
766
    }
767
768
    c->predictor += (c->step * yamaha_difflookup[nibble]) / 8;
769
    CLAMP_TO_SHORT(c->predictor);
770
    c->step = (c->step * yamaha_indexscale[nibble]) >> 8;
771 f66e4f5f Reimar Döffinger
    c->step = av_clip(c->step, 127, 24567);
772 2ff4524e Vidar Madsen
    return c->predictor;
773
}
774
775 115329f1 Diego Biurrun
static void xa_decode(short *out, const unsigned char *in,
776 fc384777 Mike Melanson
    ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
777
{
778
    int i, j;
779
    int shift,filter,f0,f1;
780
    int s_1,s_2;
781
    int d,s,t;
782
783
    for(i=0;i<4;i++) {
784
785
        shift  = 12 - (in[4+i*2] & 15);
786
        filter = in[4+i*2] >> 4;
787
        f0 = xa_adpcm_table[filter][0];
788
        f1 = xa_adpcm_table[filter][1];
789
790
        s_1 = left->sample1;
791
        s_2 = left->sample2;
792
793
        for(j=0;j<28;j++) {
794
            d = in[16+i+j*4];
795
796
            t = (signed char)(d<<4)>>4;
797
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
798
            CLAMP_TO_SHORT(s);
799
            *out = s;
800
            out += inc;
801
            s_2 = s_1;
802
            s_1 = s;
803
        }
804
805
        if (inc==2) { /* stereo */
806
            left->sample1 = s_1;
807
            left->sample2 = s_2;
808
            s_1 = right->sample1;
809
            s_2 = right->sample2;
810
            out = out + 1 - 28*2;
811
        }
812
813
        shift  = 12 - (in[5+i*2] & 15);
814
        filter = in[5+i*2] >> 4;
815
816
        f0 = xa_adpcm_table[filter][0];
817
        f1 = xa_adpcm_table[filter][1];
818
819
        for(j=0;j<28;j++) {
820
            d = in[16+i+j*4];
821
822
            t = (signed char)d >> 4;
823
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
824
            CLAMP_TO_SHORT(s);
825
            *out = s;
826
            out += inc;
827
            s_2 = s_1;
828
            s_1 = s;
829
        }
830
831
        if (inc==2) { /* stereo */
832
            right->sample1 = s_1;
833
            right->sample2 = s_2;
834
            out -= 1;
835
        } else {
836
            left->sample1 = s_1;
837
            left->sample2 = s_2;
838
        }
839
    }
840
}
841
842
843 9937e686 Mike Melanson
/* DK3 ADPCM support macro */
844
#define DK3_GET_NEXT_NIBBLE() \
845
    if (decode_top_nibble_next) \
846
    { \
847
        nibble = (last_byte >> 4) & 0x0F; \
848
        decode_top_nibble_next = 0; \
849
    } \
850
    else \
851
    { \
852
        last_byte = *src++; \
853
        if (src >= buf + buf_size) break; \
854
        nibble = last_byte & 0x0F; \
855
        decode_top_nibble_next = 1; \
856
    }
857
858 0147f198 François Revol
static int adpcm_decode_frame(AVCodecContext *avctx,
859 bb270c08 Diego Biurrun
                            void *data, int *data_size,
860
                            uint8_t *buf, int buf_size)
861 0147f198 François Revol
{
862
    ADPCMContext *c = avctx->priv_data;
863
    ADPCMChannelStatus *cs;
864 4b465299 Michael Niedermayer
    int n, m, channel, i;
865 0147f198 François Revol
    int block_predictor[2];
866
    short *samples;
867 14c49573 Michael Niedermayer
    short *samples_end;
868 0c1a9eda Zdenek Kabelac
    uint8_t *src;
869 0147f198 François Revol
    int st; /* stereo */
870
871 9937e686 Mike Melanson
    /* DK3 ADPCM accounting variables */
872
    unsigned char last_byte = 0;
873
    unsigned char nibble;
874
    int decode_top_nibble_next = 0;
875
    int diff_channel;
876
877 7d8379f2 Mike Melanson
    /* EA ADPCM state variables */
878
    uint32_t samples_in_chunk;
879
    int32_t previous_left_sample, previous_right_sample;
880
    int32_t current_left_sample, current_right_sample;
881
    int32_t next_left_sample, next_right_sample;
882
    int32_t coeff1l, coeff2l, coeff1r, coeff2r;
883
    uint8_t shift_left, shift_right;
884
    int count1, count2;
885
886 df72754d Mike Melanson
    if (!buf_size)
887
        return 0;
888
889 14c49573 Michael Niedermayer
    //should protect all 4bit ADPCM variants
890
    //8 is needed for CODEC_ID_ADPCM_IMA_WAV with 2 channels
891
    //
892
    if(*data_size/4 < buf_size + 8)
893
        return -1;
894
895 0147f198 François Revol
    samples = data;
896 14c49573 Michael Niedermayer
    samples_end= samples + *data_size/2;
897
    *data_size= 0;
898 0147f198 François Revol
    src = buf;
899
900 2433f24f Aurelien Jacobs
    st = avctx->channels == 2 ? 1 : 0;
901 0147f198 François Revol
902
    switch(avctx->codec->id) {
903
    case CODEC_ID_ADPCM_IMA_QT:
904
        n = (buf_size - 2);/* >> 2*avctx->channels;*/
905
        channel = c->channel;
906
        cs = &(c->status[channel]);
907
        /* (pppppp) (piiiiiii) */
908
909
        /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
910
        cs->predictor = (*src++) << 8;
911
        cs->predictor |= (*src & 0x80);
912
        cs->predictor &= 0xFF80;
913
914
        /* sign extension */
915
        if(cs->predictor & 0x8000)
916
            cs->predictor -= 0x10000;
917
918
        CLAMP_TO_SHORT(cs->predictor);
919
920
        cs->step_index = (*src++) & 0x7F;
921
922 8d359bba Michael Niedermayer
        if (cs->step_index > 88){
923
            av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
924
            cs->step_index = 88;
925
        }
926 0147f198 François Revol
927
        cs->step = step_table[cs->step_index];
928
929
        if (st && channel)
930
            samples++;
931
932
        for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
933 d94728c3 Michael Niedermayer
            *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3);
934 0147f198 François Revol
            samples += avctx->channels;
935 d94728c3 Michael Niedermayer
            *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F, 3);
936 0147f198 François Revol
            samples += avctx->channels;
937
            src ++;
938
        }
939
940
        if(st) { /* handle stereo interlacing */
941
            c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
942 ac3d5cac Mike Melanson
            if(channel == 1) { /* wait for the other packet before outputing anything */
943 0147f198 François Revol
                return src - buf;
944
            }
945
        }
946
        break;
947
    case CODEC_ID_ADPCM_IMA_WAV:
948 ca1d62f4 Assaf Yaari
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
949
            buf_size = avctx->block_align;
950
951 8d359bba Michael Niedermayer
//        samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1;
952
953 d94728c3 Michael Niedermayer
        for(i=0; i<avctx->channels; i++){
954
            cs = &(c->status[i]);
955 8d359bba Michael Niedermayer
            cs->predictor = (int16_t)(src[0] + (src[1]<<8));
956
            src+=2;
957 0147f198 François Revol
958 bb270c08 Diego Biurrun
        // XXX: is this correct ??: *samples++ = cs->predictor;
959 889c5224 François Revol
960 d94728c3 Michael Niedermayer
            cs->step_index = *src++;
961 8d359bba Michael Niedermayer
            if (cs->step_index > 88){
962
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
963
                cs->step_index = 88;
964
            }
965
            if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */
966 0147f198 François Revol
        }
967
968 8d359bba Michael Niedermayer
        while(src < buf + buf_size){
969
            for(m=0; m<4; m++){
970
                for(i=0; i<=st; i++)
971
                    *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3);
972
                for(i=0; i<=st; i++)
973
                    *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4  , 3);
974
                src++;
975 bb270c08 Diego Biurrun
            }
976 8d359bba Michael Niedermayer
            src += 4*st;
977 bb270c08 Diego Biurrun
        }
978 0147f198 François Revol
        break;
979 4b465299 Michael Niedermayer
    case CODEC_ID_ADPCM_4XM:
980
        cs = &(c->status[0]);
981
        c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
982
        if(st){
983
            c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
984
        }
985
        c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
986
        if(st){
987
            c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
988
        }
989 ac3d5cac Mike Melanson
        if (cs->step_index < 0) cs->step_index = 0;
990
        if (cs->step_index > 88) cs->step_index = 88;
991 4b465299 Michael Niedermayer
992
        m= (buf_size - (src - buf))>>st;
993
        for(i=0; i<m; i++) {
994 bb270c08 Diego Biurrun
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);
995 4b465299 Michael Niedermayer
            if (st)
996 d94728c3 Michael Niedermayer
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);
997
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);
998 bb270c08 Diego Biurrun
            if (st)
999 d94728c3 Michael Niedermayer
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);
1000 bb270c08 Diego Biurrun
        }
1001 4b465299 Michael Niedermayer
1002
        src += m<<st;
1003
1004
        break;
1005 0147f198 François Revol
    case CODEC_ID_ADPCM_MS:
1006 ca1d62f4 Assaf Yaari
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
1007
            buf_size = avctx->block_align;
1008 0147f198 François Revol
        n = buf_size - 7 * avctx->channels;
1009
        if (n < 0)
1010
            return -1;
1011 f66e4f5f Reimar Döffinger
        block_predictor[0] = av_clip(*src++, 0, 7);
1012 0147f198 François Revol
        block_predictor[1] = 0;
1013
        if (st)
1014 f66e4f5f Reimar Döffinger
            block_predictor[1] = av_clip(*src++, 0, 7);
1015 6cf9d5eb Michael Niedermayer
        c->status[0].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1016 0147f198 François Revol
        src+=2;
1017 6cf9d5eb Michael Niedermayer
        if (st){
1018
            c->status[1].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1019 0147f198 François Revol
            src+=2;
1020 6cf9d5eb Michael Niedermayer
        }
1021 0147f198 François Revol
        c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
1022
        c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
1023
        c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
1024
        c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
1025 115329f1 Diego Biurrun
1026 0147f198 François Revol
        c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1027
        src+=2;
1028
        if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1029
        if (st) src+=2;
1030
        c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1031
        src+=2;
1032
        if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1033
        if (st) src+=2;
1034
1035
        *samples++ = c->status[0].sample1;
1036
        if (st) *samples++ = c->status[1].sample1;
1037
        *samples++ = c->status[0].sample2;
1038
        if (st) *samples++ = c->status[1].sample2;
1039
        for(;n>0;n--) {
1040
            *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
1041
            *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
1042
            src ++;
1043
        }
1044
        break;
1045 9937e686 Mike Melanson
    case CODEC_ID_ADPCM_IMA_DK4:
1046 5c69a4fd Michael Niedermayer
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
1047
            buf_size = avctx->block_align;
1048
1049 6cf9d5eb Michael Niedermayer
        c->status[0].predictor = (int16_t)(src[0] | (src[1] << 8));
1050 9937e686 Mike Melanson
        c->status[0].step_index = src[2];
1051
        src += 4;
1052
        *samples++ = c->status[0].predictor;
1053
        if (st) {
1054 6cf9d5eb Michael Niedermayer
            c->status[1].predictor = (int16_t)(src[0] | (src[1] << 8));
1055 9937e686 Mike Melanson
            c->status[1].step_index = src[2];
1056
            src += 4;
1057
            *samples++ = c->status[1].predictor;
1058
        }
1059
        while (src < buf + buf_size) {
1060
1061
            /* take care of the top nibble (always left or mono channel) */
1062 115329f1 Diego Biurrun
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1063 d94728c3 Michael Niedermayer
                (src[0] >> 4) & 0x0F, 3);
1064 9937e686 Mike Melanson
1065
            /* take care of the bottom nibble, which is right sample for
1066
             * stereo, or another mono sample */
1067
            if (st)
1068 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[1],
1069 d94728c3 Michael Niedermayer
                    src[0] & 0x0F, 3);
1070 9937e686 Mike Melanson
            else
1071 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1072 d94728c3 Michael Niedermayer
                    src[0] & 0x0F, 3);
1073 9937e686 Mike Melanson
1074
            src++;
1075
        }
1076
        break;
1077
    case CODEC_ID_ADPCM_IMA_DK3:
1078 5c69a4fd Michael Niedermayer
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
1079
            buf_size = avctx->block_align;
1080
1081 14c49573 Michael Niedermayer
        if(buf_size + 16 > (samples_end - samples)*3/8)
1082
            return -1;
1083
1084 6cf9d5eb Michael Niedermayer
        c->status[0].predictor = (int16_t)(src[10] | (src[11] << 8));
1085
        c->status[1].predictor = (int16_t)(src[12] | (src[13] << 8));
1086 9937e686 Mike Melanson
        c->status[0].step_index = src[14];
1087
        c->status[1].step_index = src[15];
1088
        /* sign extend the predictors */
1089
        src += 16;
1090
        diff_channel = c->status[1].predictor;
1091
1092
        /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
1093
         * the buffer is consumed */
1094
        while (1) {
1095
1096
            /* for this algorithm, c->status[0] is the sum channel and
1097
             * c->status[1] is the diff channel */
1098
1099
            /* process the first predictor of the sum channel */
1100
            DK3_GET_NEXT_NIBBLE();
1101 d94728c3 Michael Niedermayer
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1102 9937e686 Mike Melanson
1103
            /* process the diff channel predictor */
1104
            DK3_GET_NEXT_NIBBLE();
1105 d94728c3 Michael Niedermayer
            adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
1106 9937e686 Mike Melanson
1107
            /* process the first pair of stereo PCM samples */
1108
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
1109
            *samples++ = c->status[0].predictor + c->status[1].predictor;
1110
            *samples++ = c->status[0].predictor - c->status[1].predictor;
1111
1112
            /* process the second predictor of the sum channel */
1113
            DK3_GET_NEXT_NIBBLE();
1114 d94728c3 Michael Niedermayer
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1115 9937e686 Mike Melanson
1116
            /* process the second pair of stereo PCM samples */
1117
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
1118
            *samples++ = c->status[0].predictor + c->status[1].predictor;
1119
            *samples++ = c->status[0].predictor - c->status[1].predictor;
1120
        }
1121
        break;
1122 2fdf638b Mike Melanson
    case CODEC_ID_ADPCM_IMA_WS:
1123
        /* no per-block initialization; just start decoding the data */
1124
        while (src < buf + buf_size) {
1125
1126
            if (st) {
1127 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1128 d94728c3 Michael Niedermayer
                    (src[0] >> 4) & 0x0F, 3);
1129 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[1],
1130 d94728c3 Michael Niedermayer
                    src[0] & 0x0F, 3);
1131 2fdf638b Mike Melanson
            } else {
1132 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1133 d94728c3 Michael Niedermayer
                    (src[0] >> 4) & 0x0F, 3);
1134 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1135 d94728c3 Michael Niedermayer
                    src[0] & 0x0F, 3);
1136 2fdf638b Mike Melanson
            }
1137
1138
            src++;
1139
        }
1140
        break;
1141 fc384777 Mike Melanson
    case CODEC_ID_ADPCM_XA:
1142 115329f1 Diego Biurrun
        c->status[0].sample1 = c->status[0].sample2 =
1143 fc384777 Mike Melanson
        c->status[1].sample1 = c->status[1].sample2 = 0;
1144
        while (buf_size >= 128) {
1145 115329f1 Diego Biurrun
            xa_decode(samples, src, &c->status[0], &c->status[1],
1146 fc384777 Mike Melanson
                avctx->channels);
1147
            src += 128;
1148
            samples += 28 * 8;
1149
            buf_size -= 128;
1150
        }
1151
        break;
1152 7d8379f2 Mike Melanson
    case CODEC_ID_ADPCM_EA:
1153 fead30d4 Alex Beregszaszi
        samples_in_chunk = AV_RL32(src);
1154 7d8379f2 Mike Melanson
        if (samples_in_chunk >= ((buf_size - 12) * 2)) {
1155
            src += buf_size;
1156
            break;
1157
        }
1158
        src += 4;
1159 fead30d4 Alex Beregszaszi
        current_left_sample = (int16_t)AV_RL16(src);
1160 7d8379f2 Mike Melanson
        src += 2;
1161 fead30d4 Alex Beregszaszi
        previous_left_sample = (int16_t)AV_RL16(src);
1162 7d8379f2 Mike Melanson
        src += 2;
1163 fead30d4 Alex Beregszaszi
        current_right_sample = (int16_t)AV_RL16(src);
1164 7d8379f2 Mike Melanson
        src += 2;
1165 fead30d4 Alex Beregszaszi
        previous_right_sample = (int16_t)AV_RL16(src);
1166 7d8379f2 Mike Melanson
        src += 2;
1167
1168
        for (count1 = 0; count1 < samples_in_chunk/28;count1++) {
1169
            coeff1l = ea_adpcm_table[(*src >> 4) & 0x0F];
1170
            coeff2l = ea_adpcm_table[((*src >> 4) & 0x0F) + 4];
1171
            coeff1r = ea_adpcm_table[*src & 0x0F];
1172
            coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
1173
            src++;
1174
1175
            shift_left = ((*src >> 4) & 0x0F) + 8;
1176
            shift_right = (*src & 0x0F) + 8;
1177
            src++;
1178
1179
            for (count2 = 0; count2 < 28; count2++) {
1180
                next_left_sample = (((*src & 0xF0) << 24) >> shift_left);
1181
                next_right_sample = (((*src & 0x0F) << 28) >> shift_right);
1182
                src++;
1183
1184 115329f1 Diego Biurrun
                next_left_sample = (next_left_sample +
1185
                    (current_left_sample * coeff1l) +
1186 7d8379f2 Mike Melanson
                    (previous_left_sample * coeff2l) + 0x80) >> 8;
1187 115329f1 Diego Biurrun
                next_right_sample = (next_right_sample +
1188
                    (current_right_sample * coeff1r) +
1189 7d8379f2 Mike Melanson
                    (previous_right_sample * coeff2r) + 0x80) >> 8;
1190
                CLAMP_TO_SHORT(next_left_sample);
1191
                CLAMP_TO_SHORT(next_right_sample);
1192
1193
                previous_left_sample = current_left_sample;
1194
                current_left_sample = next_left_sample;
1195
                previous_right_sample = current_right_sample;
1196
                current_right_sample = next_right_sample;
1197
                *samples++ = (unsigned short)current_left_sample;
1198
                *samples++ = (unsigned short)current_right_sample;
1199
            }
1200
        }
1201
        break;
1202
    case CODEC_ID_ADPCM_IMA_SMJPEG:
1203
        c->status[0].predictor = *src;
1204
        src += 2;
1205
        c->status[0].step_index = *src++;
1206
        src++;  /* skip another byte before getting to the meat */
1207
        while (src < buf + buf_size) {
1208
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1209
                *src & 0x0F, 3);
1210
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1211
                (*src >> 4) & 0x0F, 3);
1212
            src++;
1213
        }
1214
        break;
1215 b3bfb299 Mike Melanson
    case CODEC_ID_ADPCM_CT:
1216 bb270c08 Diego Biurrun
        while (src < buf + buf_size) {
1217 b3bfb299 Mike Melanson
            if (st) {
1218 115329f1 Diego Biurrun
                *samples++ = adpcm_ct_expand_nibble(&c->status[0],
1219 b3bfb299 Mike Melanson
                    (src[0] >> 4) & 0x0F);
1220 115329f1 Diego Biurrun
                *samples++ = adpcm_ct_expand_nibble(&c->status[1],
1221 b3bfb299 Mike Melanson
                    src[0] & 0x0F);
1222
            } else {
1223 115329f1 Diego Biurrun
                *samples++ = adpcm_ct_expand_nibble(&c->status[0],
1224 b3bfb299 Mike Melanson
                    (src[0] >> 4) & 0x0F);
1225 115329f1 Diego Biurrun
                *samples++ = adpcm_ct_expand_nibble(&c->status[0],
1226 b3bfb299 Mike Melanson
                    src[0] & 0x0F);
1227
            }
1228 bb270c08 Diego Biurrun
            src++;
1229 b3bfb299 Mike Melanson
        }
1230
        break;
1231 2433f24f Aurelien Jacobs
    case CODEC_ID_ADPCM_SBPRO_4:
1232
    case CODEC_ID_ADPCM_SBPRO_3:
1233
    case CODEC_ID_ADPCM_SBPRO_2:
1234
        if (!c->status[0].step_index) {
1235
            /* the first byte is a raw sample */
1236
            *samples++ = 128 * (*src++ - 0x80);
1237
            if (st)
1238
              *samples++ = 128 * (*src++ - 0x80);
1239
            c->status[0].step_index = 1;
1240
        }
1241
        if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) {
1242
            while (src < buf + buf_size) {
1243
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1244
                    (src[0] >> 4) & 0x0F, 4, 0);
1245
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1246
                    src[0] & 0x0F, 4, 0);
1247
                src++;
1248
            }
1249
        } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) {
1250 14c49573 Michael Niedermayer
            while (src < buf + buf_size && samples + 2 < samples_end) {
1251 2433f24f Aurelien Jacobs
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1252
                    (src[0] >> 5) & 0x07, 3, 0);
1253
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1254
                    (src[0] >> 2) & 0x07, 3, 0);
1255
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1256
                    src[0] & 0x03, 2, 0);
1257
                src++;
1258
            }
1259
        } else {
1260 14c49573 Michael Niedermayer
            while (src < buf + buf_size && samples + 3 < samples_end) {
1261 2433f24f Aurelien Jacobs
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1262
                    (src[0] >> 6) & 0x03, 2, 2);
1263
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1264
                    (src[0] >> 4) & 0x03, 2, 2);
1265
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1266
                    (src[0] >> 2) & 0x03, 2, 2);
1267
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1268
                    src[0] & 0x03, 2, 2);
1269
                src++;
1270
            }
1271
        }
1272
        break;
1273 659c3692 Alex Beregszaszi
    case CODEC_ID_ADPCM_SWF:
1274
    {
1275 bb270c08 Diego Biurrun
        GetBitContext gb;
1276
        const int *table;
1277 fe4ff07a Baptiste Coudurier
        int k0, signmask, nb_bits, count;
1278 bb270c08 Diego Biurrun
        int size = buf_size*8;
1279
1280
        init_get_bits(&gb, buf, size);
1281
1282 90b5b51e Diego Biurrun
        //read bits & initial values
1283 387afa9d Baptiste Coudurier
        nb_bits = get_bits(&gb, 2)+2;
1284
        //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits);
1285
        table = swf_index_tables[nb_bits-2];
1286
        k0 = 1 << (nb_bits-2);
1287
        signmask = 1 << (nb_bits-1);
1288 bb270c08 Diego Biurrun
1289 fe4ff07a Baptiste Coudurier
        while (get_bits_count(&gb) <= size - 22*avctx->channels) {
1290 387afa9d Baptiste Coudurier
        for (i = 0; i < avctx->channels; i++) {
1291
            *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
1292
            c->status[i].step_index = get_bits(&gb, 6);
1293
        }
1294 bb270c08 Diego Biurrun
1295 fe4ff07a Baptiste Coudurier
        for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++)
1296 bb270c08 Diego Biurrun
        {
1297
            int i;
1298
1299 387afa9d Baptiste Coudurier
            for (i = 0; i < avctx->channels; i++) {
1300
                // similar to IMA adpcm
1301
                int delta = get_bits(&gb, nb_bits);
1302 bb270c08 Diego Biurrun
                int step = step_table[c->status[i].step_index];
1303
                long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
1304
                int k = k0;
1305
1306
                do {
1307
                    if (delta & k)
1308
                        vpdiff += step;
1309
                    step >>= 1;
1310
                    k >>= 1;
1311
                } while(k);
1312
                vpdiff += step;
1313
1314
                if (delta & signmask)
1315
                    c->status[i].predictor -= vpdiff;
1316
                else
1317
                    c->status[i].predictor += vpdiff;
1318
1319
                c->status[i].step_index += table[delta & (~signmask)];
1320
1321 f66e4f5f Reimar Döffinger
                c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
1322
                c->status[i].predictor = av_clip(c->status[i].predictor, -32768, 32767);
1323 bb270c08 Diego Biurrun
1324
                *samples++ = c->status[i].predictor;
1325 387afa9d Baptiste Coudurier
                if (samples >= samples_end) {
1326
                    av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");
1327
                    return -1;
1328
                }
1329 bb270c08 Diego Biurrun
            }
1330
        }
1331 fe4ff07a Baptiste Coudurier
        }
1332 387afa9d Baptiste Coudurier
        src += buf_size;
1333 bb270c08 Diego Biurrun
        break;
1334 659c3692 Alex Beregszaszi
    }
1335 2ff4524e Vidar Madsen
    case CODEC_ID_ADPCM_YAMAHA:
1336
        while (src < buf + buf_size) {
1337
            if (st) {
1338
                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
1339
                        src[0] & 0x0F);
1340 b194c327 Michael Niedermayer
                *samples++ = adpcm_yamaha_expand_nibble(&c->status[1],
1341 2ff4524e Vidar Madsen
                        (src[0] >> 4) & 0x0F);
1342 b194c327 Michael Niedermayer
            } else {
1343 2ff4524e Vidar Madsen
                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
1344
                        src[0] & 0x0F);
1345 b194c327 Michael Niedermayer
                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
1346
                        (src[0] >> 4) & 0x0F);
1347 2ff4524e Vidar Madsen
            }
1348
            src++;
1349
        }
1350
        break;
1351 d1e0d21f Marco Gerards
    case CODEC_ID_ADPCM_THP:
1352 90f2a1a0 Marco Gerards
    {
1353 20f75707 Michael Niedermayer
        int table[2][16];
1354 d1e0d21f Marco Gerards
        unsigned int samplecnt;
1355 b736a365 Michael Niedermayer
        int prev[2][2];
1356 d1e0d21f Marco Gerards
        int ch;
1357
1358
        if (buf_size < 80) {
1359
            av_log(avctx, AV_LOG_ERROR, "frame too small\n");
1360
            return -1;
1361
        }
1362
1363 949ed6bb Michael Niedermayer
        src+=4;
1364
        samplecnt = bytestream_get_be32(&src);
1365 d1e0d21f Marco Gerards
1366 11d66266 Michael Niedermayer
        for (i = 0; i < 32; i++)
1367 949ed6bb Michael Niedermayer
            table[0][i] = (int16_t)bytestream_get_be16(&src);
1368 d1e0d21f Marco Gerards
1369
        /* Initialize the previous sample.  */
1370 204424a4 Michael Niedermayer
        for (i = 0; i < 4; i++)
1371 949ed6bb Michael Niedermayer
            prev[0][i] = (int16_t)bytestream_get_be16(&src);
1372 d1e0d21f Marco Gerards
1373
        if (samplecnt >= (samples_end - samples) /  (st + 1)) {
1374
            av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");
1375
            return -1;
1376
        }
1377
1378
        for (ch = 0; ch <= st; ch++) {
1379
            samples = (unsigned short *) data + ch;
1380
1381
            /* Read in every sample for this channel.  */
1382
            for (i = 0; i < samplecnt / 14; i++) {
1383 949ed6bb Michael Niedermayer
                int index = (*src >> 4) & 7;
1384
                unsigned int exp = 28 - (*src++ & 15);
1385 20f75707 Michael Niedermayer
                int factor1 = table[ch][index * 2];
1386
                int factor2 = table[ch][index * 2 + 1];
1387 d1e0d21f Marco Gerards
1388
                /* Decode 14 samples.  */
1389
                for (n = 0; n < 14; n++) {
1390 949ed6bb Michael Niedermayer
                    int32_t sampledat;
1391
                    if(n&1) sampledat=  *src++    <<28;
1392
                    else    sampledat= (*src&0xF0)<<24;
1393 d1e0d21f Marco Gerards
1394 e457023a Marco Gerards
                    sampledat = ((prev[ch][0]*factor1
1395 949ed6bb Michael Niedermayer
                                + prev[ch][1]*factor2) >> 11) + (sampledat>>exp);
1396 e457023a Marco Gerards
                    CLAMP_TO_SHORT(sampledat);
1397
                    *samples = sampledat;
1398 b736a365 Michael Niedermayer
                    prev[ch][1] = prev[ch][0];
1399
                    prev[ch][0] = *samples++;
1400 d1e0d21f Marco Gerards
1401
                    /* In case of stereo, skip one sample, this sample
1402
                       is for the other channel.  */
1403
                    samples += st;
1404
                }
1405
            }
1406
        }
1407
1408
        /* In the previous loop, in case stereo is used, samples is
1409
           increased exactly one time too often.  */
1410
        samples -= st;
1411
        break;
1412 90f2a1a0 Marco Gerards
    }
1413 d1e0d21f Marco Gerards
1414 0147f198 François Revol
    default:
1415
        return -1;
1416
    }
1417 0c1a9eda Zdenek Kabelac
    *data_size = (uint8_t *)samples - (uint8_t *)data;
1418 0147f198 François Revol
    return src - buf;
1419
}
1420
1421 764ef400 Mike Melanson
1422
1423
#ifdef CONFIG_ENCODERS
1424
#define ADPCM_ENCODER(id,name)                  \
1425 0147f198 François Revol
AVCodec name ## _encoder = {                    \
1426
    #name,                                      \
1427
    CODEC_TYPE_AUDIO,                           \
1428
    id,                                         \
1429
    sizeof(ADPCMContext),                       \
1430
    adpcm_encode_init,                          \
1431
    adpcm_encode_frame,                         \
1432
    adpcm_encode_close,                         \
1433
    NULL,                                       \
1434 764ef400 Mike Melanson
};
1435
#else
1436
#define ADPCM_ENCODER(id,name)
1437
#endif
1438
1439
#ifdef CONFIG_DECODERS
1440
#define ADPCM_DECODER(id,name)                  \
1441 0147f198 François Revol
AVCodec name ## _decoder = {                    \
1442
    #name,                                      \
1443
    CODEC_TYPE_AUDIO,                           \
1444
    id,                                         \
1445
    sizeof(ADPCMContext),                       \
1446
    adpcm_decode_init,                          \
1447
    NULL,                                       \
1448
    NULL,                                       \
1449
    adpcm_decode_frame,                         \
1450
};
1451 764ef400 Mike Melanson
#else
1452
#define ADPCM_DECODER(id,name)
1453
#endif
1454
1455
#define ADPCM_CODEC(id, name)                   \
1456
ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)
1457 0147f198 François Revol
1458
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
1459
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
1460 9937e686 Mike Melanson
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);
1461
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);
1462 2fdf638b Mike Melanson
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);
1463 7d8379f2 Mike Melanson
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
1464 0147f198 François Revol
ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
1465 4b465299 Michael Niedermayer
ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm);
1466 fc384777 Mike Melanson
ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa);
1467 7d8379f2 Mike Melanson
ADPCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea);
1468 b3bfb299 Mike Melanson
ADPCM_CODEC(CODEC_ID_ADPCM_CT, adpcm_ct);
1469 659c3692 Alex Beregszaszi
ADPCM_CODEC(CODEC_ID_ADPCM_SWF, adpcm_swf);
1470 2ff4524e Vidar Madsen
ADPCM_CODEC(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha);
1471 2433f24f Aurelien Jacobs
ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4);
1472
ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3);
1473
ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2);
1474 d1e0d21f Marco Gerards
ADPCM_CODEC(CODEC_ID_ADPCM_THP, adpcm_thp);
1475 0147f198 François Revol
1476
#undef ADPCM_CODEC