Statistics
| Branch: | Revision:

ffmpeg / libavcodec / adpcm.c @ 9106a698

History | View | Annotate | Download (61.5 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 9106a698 Stefano Sabatini
#include "get_bits.h"
23 b2755007 Stefano Sabatini
#include "put_bits.h"
24 949ed6bb Michael Niedermayer
#include "bytestream.h"
25 0147f198 François Revol
26 983e3246 Michael Niedermayer
/**
27 bad5537e Diego Biurrun
 * @file libavcodec/adpcm.c
28 983e3246 Michael Niedermayer
 * ADPCM codecs.
29 fc384777 Mike Melanson
 * First version by Francois Revol (revol@free.fr)
30 2fdf638b Mike Melanson
 * Fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
31 9937e686 Mike Melanson
 *   by Mike Melanson (melanson@pcisys.net)
32 fc384777 Mike Melanson
 * CD-ROM XA ADPCM codec by BERO
33 7d8379f2 Mike Melanson
 * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com)
34 e7583962 Peter Ross
 * EA ADPCM R1/R2/R3 decoder by Peter Ross (pross@xvid.org)
35 fac84d3c Peter Ross
 * EA IMA EACS decoder by Peter Ross (pross@xvid.org)
36 7bb65d89 Peter Ross
 * EA IMA SEAD decoder by Peter Ross (pross@xvid.org)
37 271b4095 Aurelien Jacobs
 * EA ADPCM XAS decoder by Peter Ross (pross@xvid.org)
38 861c63a2 Robert Marston
 * MAXIS EA ADPCM decoder by Robert Marston (rmarston@gmail.com)
39 d1e0d21f Marco Gerards
 * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl)
40 0147f198 François Revol
 *
41
 * Features and limitations:
42
 *
43
 * Reference documents:
44 9937e686 Mike Melanson
 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html
45 0147f198 François Revol
 * http://www.geocities.com/SiliconValley/8682/aud3.txt
46
 * http://openquicktime.sourceforge.net/plugins.htm
47
 * XAnim sources (xa_codec.c) http://www.rasnaimaging.com/people/lapus/download.html
48 889c5224 François Revol
 * http://www.cs.ucla.edu/~leec/mediabench/applications.html
49
 * SoX source code http://home.sprynet.com/~cbagwell/sox.html
50 fc384777 Mike Melanson
 *
51
 * CD-ROM XA:
52
 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html
53
 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html
54
 * readstr http://www.geocities.co.jp/Playtown/2004/
55 0147f198 François Revol
 */
56
57
#define BLKSIZE 1024
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 8884b918 Reimar Döffinger
static const uint8_t AdaptCoeff1[] = {
90 ddcf031f Reimar Döffinger
        64, 128, 0, 48, 60, 115, 98
91 0147f198 François Revol
};
92
93 ddcf031f Reimar Döffinger
static const int8_t AdaptCoeff2[] = {
94
        0, -64, 0, 16, 0, -52, -58
95 0147f198 François Revol
};
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 659c3692 Alex Beregszaszi
// padded to zero where table size is less then 16
112 c26ae41d Michael Niedermayer
static const int swf_index_tables[4][16] = {
113 659c3692 Alex Beregszaszi
    /*2*/ { -1, 2 },
114
    /*3*/ { -1, -1, 2, 4 },
115
    /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },
116
    /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
117
};
118
119 2ff4524e Vidar Madsen
static const int yamaha_indexscale[] = {
120
    230, 230, 230, 230, 307, 409, 512, 614,
121
    230, 230, 230, 230, 307, 409, 512, 614
122
};
123
124
static const int yamaha_difflookup[] = {
125
    1, 3, 5, 7, 9, 11, 13, 15,
126
    -1, -3, -5, -7, -9, -11, -13, -15
127
};
128
129 0147f198 François Revol
/* end of tables */
130
131
typedef struct ADPCMChannelStatus {
132
    int predictor;
133
    short int step_index;
134
    int step;
135 889c5224 François Revol
    /* for encoding */
136
    int prev_sample;
137 0147f198 François Revol
138
    /* MS version */
139
    short sample1;
140
    short sample2;
141
    int coeff1;
142
    int coeff2;
143
    int idelta;
144
} ADPCMChannelStatus;
145
146
typedef struct ADPCMContext {
147 e7583962 Peter Ross
    ADPCMChannelStatus status[6];
148 0147f198 François Revol
} ADPCMContext;
149
150
/* XXX: implement encoding */
151
152 b250f9c6 Aurelien Jacobs
#if CONFIG_ENCODERS
153 5ef251e5 Daniel Verkamp
static av_cold int adpcm_encode_init(AVCodecContext *avctx)
154 0147f198 François Revol
{
155 889c5224 François Revol
    if (avctx->channels > 2)
156
        return -1; /* only stereo or mono =) */
157 909a9ad0 Michael Niedermayer
158
    if(avctx->trellis && (unsigned)avctx->trellis > 16U){
159
        av_log(avctx, AV_LOG_ERROR, "invalid trellis size\n");
160
        return -1;
161
    }
162
163 0147f198 François Revol
    switch(avctx->codec->id) {
164
    case CODEC_ID_ADPCM_IMA_WAV:
165 889c5224 François Revol
        avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */
166
                                                             /* and we have 4 bytes per channel overhead */
167
        avctx->block_align = BLKSIZE;
168
        /* seems frame_size isn't taken into account... have to buffer the samples :-( */
169
        break;
170 9dc92a38 Kostya Shishkov
    case CODEC_ID_ADPCM_IMA_QT:
171
        avctx->frame_size = 64;
172
        avctx->block_align = 34 * avctx->channels;
173
        break;
174 889c5224 François Revol
    case CODEC_ID_ADPCM_MS:
175 6cf9d5eb Michael Niedermayer
        avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */
176
                                                             /* and we have 7 bytes per channel overhead */
177
        avctx->block_align = BLKSIZE;
178 0147f198 François Revol
        break;
179 2ff4524e Vidar Madsen
    case CODEC_ID_ADPCM_YAMAHA:
180
        avctx->frame_size = BLKSIZE * avctx->channels;
181
        avctx->block_align = BLKSIZE;
182
        break;
183 d64b88d4 Benjamin Larsson
    case CODEC_ID_ADPCM_SWF:
184 9fff16bc Baptiste Coudurier
        if (avctx->sample_rate != 11025 &&
185
            avctx->sample_rate != 22050 &&
186
            avctx->sample_rate != 44100) {
187
            av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, 22050 or 44100\n");
188
            return -1;
189
        }
190
        avctx->frame_size = 512 * (avctx->sample_rate / 11025);
191 d64b88d4 Benjamin Larsson
        break;
192 0147f198 François Revol
    default:
193 889c5224 François Revol
        return -1;
194 0147f198 François Revol
        break;
195
    }
196 492cd3a9 Michael Niedermayer
197
    avctx->coded_frame= avcodec_alloc_frame();
198
    avctx->coded_frame->key_frame= 1;
199
200 0147f198 François Revol
    return 0;
201
}
202
203 5ef251e5 Daniel Verkamp
static av_cold int adpcm_encode_close(AVCodecContext *avctx)
204 0147f198 François Revol
{
205 492cd3a9 Michael Niedermayer
    av_freep(&avctx->coded_frame);
206
207 0147f198 François Revol
    return 0;
208
}
209
210 889c5224 François Revol
211
static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample)
212
{
213 7e537051 Loren Merritt
    int delta = sample - c->prev_sample;
214
    int nibble = FFMIN(7, abs(delta)*4/step_table[c->step_index]) + (delta<0)*8;
215 295f3737 Aurelien Jacobs
    c->prev_sample += ((step_table[c->step_index] * yamaha_difflookup[nibble]) / 8);
216 aee481ce Aurelien Jacobs
    c->prev_sample = av_clip_int16(c->prev_sample);
217 f66e4f5f Reimar Döffinger
    c->step_index = av_clip(c->step_index + index_table[nibble], 0, 88);
218 889c5224 François Revol
    return nibble;
219
}
220
221 6cf9d5eb Michael Niedermayer
static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample)
222
{
223
    int predictor, nibble, bias;
224
225 ddcf031f Reimar Döffinger
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
226 115329f1 Diego Biurrun
227 6cf9d5eb Michael Niedermayer
    nibble= sample - predictor;
228
    if(nibble>=0) bias= c->idelta/2;
229
    else          bias=-c->idelta/2;
230 115329f1 Diego Biurrun
231 6cf9d5eb Michael Niedermayer
    nibble= (nibble + bias) / c->idelta;
232 f66e4f5f Reimar Döffinger
    nibble= av_clip(nibble, -8, 7)&0x0F;
233 115329f1 Diego Biurrun
234 6cf9d5eb Michael Niedermayer
    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
235
236
    c->sample2 = c->sample1;
237 295f3737 Aurelien Jacobs
    c->sample1 = av_clip_int16(predictor);
238 6cf9d5eb Michael Niedermayer
239
    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
240
    if (c->idelta < 16) c->idelta = 16;
241
242
    return nibble;
243
}
244
245 2ff4524e Vidar Madsen
static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, short sample)
246
{
247 7e537051 Loren Merritt
    int nibble, delta;
248 2ff4524e Vidar Madsen
249
    if(!c->step) {
250
        c->predictor = 0;
251
        c->step = 127;
252
    }
253
254 7e537051 Loren Merritt
    delta = sample - c->predictor;
255 2ff4524e Vidar Madsen
256 7e537051 Loren Merritt
    nibble = FFMIN(7, abs(delta)*4/c->step) + (delta<0)*8;
257
258 295f3737 Aurelien Jacobs
    c->predictor += ((c->step * yamaha_difflookup[nibble]) / 8);
259 aee481ce Aurelien Jacobs
    c->predictor = av_clip_int16(c->predictor);
260 7e537051 Loren Merritt
    c->step = (c->step * yamaha_indexscale[nibble]) >> 8;
261 f66e4f5f Reimar Döffinger
    c->step = av_clip(c->step, 127, 24567);
262 2ff4524e Vidar Madsen
263 7e537051 Loren Merritt
    return nibble;
264 2ff4524e Vidar Madsen
}
265
266 696d6889 Loren Merritt
typedef struct TrellisPath {
267
    int nibble;
268
    int prev;
269
} TrellisPath;
270
271
typedef struct TrellisNode {
272
    uint32_t ssd;
273
    int path;
274
    int sample1;
275
    int sample2;
276
    int step;
277
} TrellisNode;
278
279
static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
280
                                   uint8_t *dst, ADPCMChannelStatus *c, int n)
281
{
282
#define FREEZE_INTERVAL 128
283
    //FIXME 6% faster if frontier is a compile-time constant
284
    const int frontier = 1 << avctx->trellis;
285
    const int stride = avctx->channels;
286
    const int version = avctx->codec->id;
287
    const int max_paths = frontier*FREEZE_INTERVAL;
288
    TrellisPath paths[max_paths], *p;
289
    TrellisNode node_buf[2][frontier];
290
    TrellisNode *nodep_buf[2][frontier];
291
    TrellisNode **nodes = nodep_buf[0]; // nodes[] is always sorted by .ssd
292
    TrellisNode **nodes_next = nodep_buf[1];
293
    int pathn = 0, froze = -1, i, j, k;
294
295
    assert(!(max_paths&(max_paths-1)));
296
297
    memset(nodep_buf, 0, sizeof(nodep_buf));
298
    nodes[0] = &node_buf[1][0];
299
    nodes[0]->ssd = 0;
300
    nodes[0]->path = 0;
301
    nodes[0]->step = c->step_index;
302
    nodes[0]->sample1 = c->sample1;
303
    nodes[0]->sample2 = c->sample2;
304 9dc92a38 Kostya Shishkov
    if((version == CODEC_ID_ADPCM_IMA_WAV) || (version == CODEC_ID_ADPCM_IMA_QT) || (version == CODEC_ID_ADPCM_SWF))
305 696d6889 Loren Merritt
        nodes[0]->sample1 = c->prev_sample;
306
    if(version == CODEC_ID_ADPCM_MS)
307
        nodes[0]->step = c->idelta;
308
    if(version == CODEC_ID_ADPCM_YAMAHA) {
309
        if(c->step == 0) {
310
            nodes[0]->step = 127;
311
            nodes[0]->sample1 = 0;
312
        } else {
313
            nodes[0]->step = c->step;
314
            nodes[0]->sample1 = c->predictor;
315
        }
316
    }
317
318
    for(i=0; i<n; i++) {
319
        TrellisNode *t = node_buf[i&1];
320
        TrellisNode **u;
321
        int sample = samples[i*stride];
322
        memset(nodes_next, 0, frontier*sizeof(TrellisNode*));
323
        for(j=0; j<frontier && nodes[j]; j++) {
324
            // higher j have higher ssd already, so they're unlikely to use a suboptimal next sample too
325
            const int range = (j < frontier/2) ? 1 : 0;
326
            const int step = nodes[j]->step;
327
            int nidx;
328
            if(version == CODEC_ID_ADPCM_MS) {
329 ddcf031f Reimar Döffinger
                const int predictor = ((nodes[j]->sample1 * c->coeff1) + (nodes[j]->sample2 * c->coeff2)) / 64;
330 696d6889 Loren Merritt
                const int div = (sample - predictor) / step;
331 f66e4f5f Reimar Döffinger
                const int nmin = av_clip(div-range, -8, 6);
332
                const int nmax = av_clip(div+range, -7, 7);
333 696d6889 Loren Merritt
                for(nidx=nmin; nidx<=nmax; nidx++) {
334
                    const int nibble = nidx & 0xf;
335
                    int dec_sample = predictor + nidx * step;
336
#define STORE_NODE(NAME, STEP_INDEX)\
337
                    int d;\
338
                    uint32_t ssd;\
339 aee481ce Aurelien Jacobs
                    dec_sample = av_clip_int16(dec_sample);\
340 696d6889 Loren Merritt
                    d = sample - dec_sample;\
341
                    ssd = nodes[j]->ssd + d*d;\
342
                    if(nodes_next[frontier-1] && ssd >= nodes_next[frontier-1]->ssd)\
343
                        continue;\
344
                    /* Collapse any two states with the same previous sample value. \
345
                     * One could also distinguish states by step and by 2nd to last
346
                     * sample, but the effects of that are negligible. */\
347
                    for(k=0; k<frontier && nodes_next[k]; k++) {\
348
                        if(dec_sample == nodes_next[k]->sample1) {\
349
                            assert(ssd >= nodes_next[k]->ssd);\
350
                            goto next_##NAME;\
351
                        }\
352
                    }\
353
                    for(k=0; k<frontier; k++) {\
354
                        if(!nodes_next[k] || ssd < nodes_next[k]->ssd) {\
355
                            TrellisNode *u = nodes_next[frontier-1];\
356
                            if(!u) {\
357
                                assert(pathn < max_paths);\
358
                                u = t++;\
359
                                u->path = pathn++;\
360
                            }\
361
                            u->ssd = ssd;\
362
                            u->step = STEP_INDEX;\
363
                            u->sample2 = nodes[j]->sample1;\
364
                            u->sample1 = dec_sample;\
365
                            paths[u->path].nibble = nibble;\
366
                            paths[u->path].prev = nodes[j]->path;\
367
                            memmove(&nodes_next[k+1], &nodes_next[k], (frontier-k-1)*sizeof(TrellisNode*));\
368
                            nodes_next[k] = u;\
369
                            break;\
370
                        }\
371
                    }\
372
                    next_##NAME:;
373
                    STORE_NODE(ms, FFMAX(16, (AdaptationTable[nibble] * step) >> 8));
374
                }
375 9dc92a38 Kostya Shishkov
            } else if((version == CODEC_ID_ADPCM_IMA_WAV)|| (version == CODEC_ID_ADPCM_IMA_QT)|| (version == CODEC_ID_ADPCM_SWF)) {
376 696d6889 Loren Merritt
#define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
377
                const int predictor = nodes[j]->sample1;\
378
                const int div = (sample - predictor) * 4 / STEP_TABLE;\
379 f66e4f5f Reimar Döffinger
                int nmin = av_clip(div-range, -7, 6);\
380
                int nmax = av_clip(div+range, -6, 7);\
381 696d6889 Loren Merritt
                if(nmin<=0) nmin--; /* distinguish -0 from +0 */\
382
                if(nmax<0) nmax--;\
383
                for(nidx=nmin; nidx<=nmax; nidx++) {\
384
                    const int nibble = nidx<0 ? 7-nidx : nidx;\
385
                    int dec_sample = predictor + (STEP_TABLE * yamaha_difflookup[nibble]) / 8;\
386
                    STORE_NODE(NAME, STEP_INDEX);\
387
                }
388 f66e4f5f Reimar Döffinger
                LOOP_NODES(ima, step_table[step], av_clip(step + index_table[nibble], 0, 88));
389 696d6889 Loren Merritt
            } else { //CODEC_ID_ADPCM_YAMAHA
390 f66e4f5f Reimar Döffinger
                LOOP_NODES(yamaha, step, av_clip((step * yamaha_indexscale[nibble]) >> 8, 127, 24567));
391 696d6889 Loren Merritt
#undef LOOP_NODES
392
#undef STORE_NODE
393
            }
394
        }
395
396
        u = nodes;
397
        nodes = nodes_next;
398
        nodes_next = u;
399
400
        // prevent overflow
401
        if(nodes[0]->ssd > (1<<28)) {
402
            for(j=1; j<frontier && nodes[j]; j++)
403
                nodes[j]->ssd -= nodes[0]->ssd;
404
            nodes[0]->ssd = 0;
405
        }
406
407
        // merge old paths to save memory
408
        if(i == froze + FREEZE_INTERVAL) {
409
            p = &paths[nodes[0]->path];
410
            for(k=i; k>froze; k--) {
411
                dst[k] = p->nibble;
412
                p = &paths[p->prev];
413
            }
414
            froze = i;
415
            pathn = 0;
416
            // other nodes might use paths that don't coincide with the frozen one.
417
            // checking which nodes do so is too slow, so just kill them all.
418
            // this also slightly improves quality, but I don't know why.
419
            memset(nodes+1, 0, (frontier-1)*sizeof(TrellisNode*));
420
        }
421
    }
422
423
    p = &paths[nodes[0]->path];
424
    for(i=n-1; i>froze; i--) {
425
        dst[i] = p->nibble;
426
        p = &paths[p->prev];
427
    }
428
429
    c->predictor = nodes[0]->sample1;
430
    c->sample1 = nodes[0]->sample1;
431
    c->sample2 = nodes[0]->sample2;
432
    c->step_index = nodes[0]->step;
433
    c->step = nodes[0]->step;
434
    c->idelta = nodes[0]->step;
435
}
436
437 0147f198 François Revol
static int adpcm_encode_frame(AVCodecContext *avctx,
438 bb270c08 Diego Biurrun
                            unsigned char *frame, int buf_size, void *data)
439 0147f198 François Revol
{
440 6cf9d5eb Michael Niedermayer
    int n, i, st;
441 0147f198 François Revol
    short *samples;
442
    unsigned char *dst;
443 889c5224 François Revol
    ADPCMContext *c = avctx->priv_data;
444
445
    dst = frame;
446
    samples = (short *)data;
447 6cf9d5eb Michael Niedermayer
    st= avctx->channels == 2;
448 889c5224 François Revol
/*    n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */
449 0147f198 François Revol
450
    switch(avctx->codec->id) {
451 889c5224 François Revol
    case CODEC_ID_ADPCM_IMA_WAV:
452
        n = avctx->frame_size / 8;
453
            c->status[0].prev_sample = (signed short)samples[0]; /* XXX */
454
/*            c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */
455 2c124cb6 Ramiro Polla
            bytestream_put_le16(&dst, c->status[0].prev_sample);
456 889c5224 François Revol
            *dst++ = (unsigned char)c->status[0].step_index;
457
            *dst++ = 0; /* unknown */
458
            samples++;
459
            if (avctx->channels == 2) {
460 62b34152 Timofei V. Bondarenko
                c->status[1].prev_sample = (signed short)samples[0];
461 889c5224 François Revol
/*                c->status[1].step_index = 0; */
462 2c124cb6 Ramiro Polla
                bytestream_put_le16(&dst, c->status[1].prev_sample);
463 889c5224 François Revol
                *dst++ = (unsigned char)c->status[1].step_index;
464
                *dst++ = 0;
465
                samples++;
466
            }
467 115329f1 Diego Biurrun
468 889c5224 François Revol
            /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */
469 696d6889 Loren Merritt
            if(avctx->trellis > 0) {
470
                uint8_t buf[2][n*8];
471
                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n*8);
472
                if(avctx->channels == 2)
473
                    adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n*8);
474
                for(i=0; i<n; i++) {
475
                    *dst++ = buf[0][8*i+0] | (buf[0][8*i+1] << 4);
476
                    *dst++ = buf[0][8*i+2] | (buf[0][8*i+3] << 4);
477
                    *dst++ = buf[0][8*i+4] | (buf[0][8*i+5] << 4);
478
                    *dst++ = buf[0][8*i+6] | (buf[0][8*i+7] << 4);
479
                    if (avctx->channels == 2) {
480
                        *dst++ = buf[1][8*i+0] | (buf[1][8*i+1] << 4);
481
                        *dst++ = buf[1][8*i+2] | (buf[1][8*i+3] << 4);
482
                        *dst++ = buf[1][8*i+4] | (buf[1][8*i+5] << 4);
483
                        *dst++ = buf[1][8*i+6] | (buf[1][8*i+7] << 4);
484
                    }
485
                }
486
            } else
487 889c5224 François Revol
            for (; n>0; n--) {
488 880de6b0 Timofei V. Bondarenko
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]);
489
                *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4;
490 889c5224 François Revol
                dst++;
491 880de6b0 Timofei V. Bondarenko
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]);
492
                *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4;
493 889c5224 François Revol
                dst++;
494 880de6b0 Timofei V. Bondarenko
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]);
495
                *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4;
496 889c5224 François Revol
                dst++;
497 880de6b0 Timofei V. Bondarenko
                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]);
498
                *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4;
499 889c5224 François Revol
                dst++;
500
                /* right channel */
501
                if (avctx->channels == 2) {
502
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]);
503
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4;
504
                    dst++;
505
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]);
506
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4;
507
                    dst++;
508
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]);
509
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;
510
                    dst++;
511
                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]);
512
                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
513
                    dst++;
514
                }
515
                samples += 8 * avctx->channels;
516
            }
517
        break;
518 9dc92a38 Kostya Shishkov
    case CODEC_ID_ADPCM_IMA_QT:
519
    {
520
        int ch, i;
521
        PutBitContext pb;
522
        init_put_bits(&pb, dst, buf_size*8);
523
524
        for(ch=0; ch<avctx->channels; ch++){
525
            put_bits(&pb, 9, (c->status[ch].prev_sample + 0x10000) >> 7);
526
            put_bits(&pb, 7, c->status[ch].step_index);
527
            if(avctx->trellis > 0) {
528
                uint8_t buf[64];
529
                adpcm_compress_trellis(avctx, samples+ch, buf, &c->status[ch], 64);
530
                for(i=0; i<64; i++)
531
                    put_bits(&pb, 4, buf[i^1]);
532
                c->status[ch].prev_sample = c->status[ch].predictor & ~0x7F;
533
            } else {
534
                for (i=0; i<64; i+=2){
535
                    int t1, t2;
536
                    t1 = adpcm_ima_compress_sample(&c->status[ch], samples[avctx->channels*(i+0)+ch]);
537
                    t2 = adpcm_ima_compress_sample(&c->status[ch], samples[avctx->channels*(i+1)+ch]);
538
                    put_bits(&pb, 4, t2);
539
                    put_bits(&pb, 4, t1);
540
                }
541
                c->status[ch].prev_sample &= ~0x7F;
542
            }
543
        }
544
545
        dst += put_bits_count(&pb)>>3;
546
        break;
547
    }
548 d64b88d4 Benjamin Larsson
    case CODEC_ID_ADPCM_SWF:
549
    {
550
        int i;
551
        PutBitContext pb;
552
        init_put_bits(&pb, dst, buf_size*8);
553
554 1cbe9d6a Benjamin Larsson
        n = avctx->frame_size-1;
555
556 d64b88d4 Benjamin Larsson
        //Store AdpcmCodeSize
557
        put_bits(&pb, 2, 2);                //Set 4bits flash adpcm format
558
559
        //Init the encoder state
560
        for(i=0; i<avctx->channels; i++){
561 ac069107 Baptiste Coudurier
            c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63); // clip step so it fits 6 bits
562 6647ab80 Ramiro Polla
            put_sbits(&pb, 16, samples[i]);
563 ac069107 Baptiste Coudurier
            put_bits(&pb, 6, c->status[i].step_index);
564 d64b88d4 Benjamin Larsson
            c->status[i].prev_sample = (signed short)samples[i];
565
        }
566
567 1cbe9d6a Benjamin Larsson
        if(avctx->trellis > 0) {
568
            uint8_t buf[2][n];
569
            adpcm_compress_trellis(avctx, samples+2, buf[0], &c->status[0], n);
570
            if (avctx->channels == 2)
571
                adpcm_compress_trellis(avctx, samples+3, buf[1], &c->status[1], n);
572
            for(i=0; i<n; i++) {
573
                put_bits(&pb, 4, buf[0][i]);
574
                if (avctx->channels == 2)
575
                    put_bits(&pb, 4, buf[1][i]);
576
            }
577
        } else {
578 622d6332 Benjamin Larsson
            for (i=1; i<avctx->frame_size; i++) {
579 880de6b0 Timofei V. Bondarenko
                put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i]));
580 622d6332 Benjamin Larsson
                if (avctx->channels == 2)
581 880de6b0 Timofei V. Bondarenko
                    put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1]));
582 1cbe9d6a Benjamin Larsson
            }
583 d64b88d4 Benjamin Larsson
        }
584 9fff16bc Baptiste Coudurier
        flush_put_bits(&pb);
585
        dst += put_bits_count(&pb)>>3;
586 d64b88d4 Benjamin Larsson
        break;
587
    }
588 6cf9d5eb Michael Niedermayer
    case CODEC_ID_ADPCM_MS:
589
        for(i=0; i<avctx->channels; i++){
590
            int predictor=0;
591
592
            *dst++ = predictor;
593
            c->status[i].coeff1 = AdaptCoeff1[predictor];
594
            c->status[i].coeff2 = AdaptCoeff2[predictor];
595
        }
596
        for(i=0; i<avctx->channels; i++){
597 115329f1 Diego Biurrun
            if (c->status[i].idelta < 16)
598 6cf9d5eb Michael Niedermayer
                c->status[i].idelta = 16;
599 115329f1 Diego Biurrun
600 2c124cb6 Ramiro Polla
            bytestream_put_le16(&dst, c->status[i].idelta);
601 6cf9d5eb Michael Niedermayer
        }
602
        for(i=0; i<avctx->channels; i++){
603 ae8afab9 Reimar Döffinger
            c->status[i].sample2= *samples++;
604
        }
605
        for(i=0; i<avctx->channels; i++){
606 6cf9d5eb Michael Niedermayer
            c->status[i].sample1= *samples++;
607
608 2c124cb6 Ramiro Polla
            bytestream_put_le16(&dst, c->status[i].sample1);
609 6cf9d5eb Michael Niedermayer
        }
610 ae8afab9 Reimar Döffinger
        for(i=0; i<avctx->channels; i++)
611 2c124cb6 Ramiro Polla
            bytestream_put_le16(&dst, c->status[i].sample2);
612 6cf9d5eb Michael Niedermayer
613 696d6889 Loren Merritt
        if(avctx->trellis > 0) {
614
            int n = avctx->block_align - 7*avctx->channels;
615
            uint8_t buf[2][n];
616
            if(avctx->channels == 1) {
617
                n *= 2;
618
                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
619
                for(i=0; i<n; i+=2)
620
                    *dst++ = (buf[0][i] << 4) | buf[0][i+1];
621
            } else {
622
                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
623
                adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
624
                for(i=0; i<n; i++)
625
                    *dst++ = (buf[0][i] << 4) | buf[1][i];
626
            }
627
        } else
628 6cf9d5eb Michael Niedermayer
        for(i=7*avctx->channels; i<avctx->block_align; i++) {
629
            int nibble;
630
            nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4;
631
            nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++);
632
            *dst++ = nibble;
633
        }
634
        break;
635 2ff4524e Vidar Madsen
    case CODEC_ID_ADPCM_YAMAHA:
636
        n = avctx->frame_size / 2;
637 696d6889 Loren Merritt
        if(avctx->trellis > 0) {
638
            uint8_t buf[2][n*2];
639
            n *= 2;
640
            if(avctx->channels == 1) {
641
                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
642
                for(i=0; i<n; i+=2)
643
                    *dst++ = buf[0][i] | (buf[0][i+1] << 4);
644
            } else {
645
                adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
646
                adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
647
                for(i=0; i<n; i++)
648
                    *dst++ = buf[0][i] | (buf[1][i] << 4);
649
            }
650
        } else
651 2ff4524e Vidar Madsen
        for (; n>0; n--) {
652
            for(i = 0; i < avctx->channels; i++) {
653
                int nibble;
654 b194c327 Michael Niedermayer
                nibble  = adpcm_yamaha_compress_sample(&c->status[i], samples[i]);
655
                nibble |= adpcm_yamaha_compress_sample(&c->status[i], samples[i+avctx->channels]) << 4;
656 2ff4524e Vidar Madsen
                *dst++ = nibble;
657
            }
658
            samples += 2 * avctx->channels;
659
        }
660
        break;
661 0147f198 François Revol
    default:
662
        return -1;
663
    }
664
    return dst - frame;
665
}
666 764ef400 Mike Melanson
#endif //CONFIG_ENCODERS
667 0147f198 François Revol
668 98a6fff9 Zuxy Meng
static av_cold int adpcm_decode_init(AVCodecContext * avctx)
669 0147f198 François Revol
{
670
    ADPCMContext *c = avctx->priv_data;
671 62377fec Baptiste Coudurier
    unsigned int max_channels = 2;
672 0147f198 François Revol
673 e7583962 Peter Ross
    switch(avctx->codec->id) {
674
    case CODEC_ID_ADPCM_EA_R1:
675
    case CODEC_ID_ADPCM_EA_R2:
676
    case CODEC_ID_ADPCM_EA_R3:
677
        max_channels = 6;
678
        break;
679
    }
680
    if(avctx->channels > max_channels){
681 14c49573 Michael Niedermayer
        return -1;
682
    }
683
684 0147f198 François Revol
    switch(avctx->codec->id) {
685 b3bfb299 Mike Melanson
    case CODEC_ID_ADPCM_CT:
686 bb270c08 Diego Biurrun
        c->status[0].step = c->status[1].step = 511;
687
        break;
688 8e952e4d Anssi Hannula
    case CODEC_ID_ADPCM_IMA_WS:
689
        if (avctx->extradata && avctx->extradata_size == 2 * 4) {
690
            c->status[0].predictor = AV_RL32(avctx->extradata);
691
            c->status[1].predictor = AV_RL32(avctx->extradata + 4);
692
        }
693
        break;
694 0147f198 François Revol
    default:
695
        break;
696
    }
697 fd76c37f Peter Ross
    avctx->sample_fmt = SAMPLE_FMT_S16;
698 0147f198 François Revol
    return 0;
699
}
700
701 d94728c3 Michael Niedermayer
static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
702 0147f198 François Revol
{
703
    int step_index;
704
    int predictor;
705
    int sign, delta, diff, step;
706
707 135ee03a Zdenek Kabelac
    step = step_table[c->step_index];
708 0147f198 François Revol
    step_index = c->step_index + index_table[(unsigned)nibble];
709
    if (step_index < 0) step_index = 0;
710 135ee03a Zdenek Kabelac
    else if (step_index > 88) step_index = 88;
711 0147f198 François Revol
712
    sign = nibble & 8;
713
    delta = nibble & 7;
714 9937e686 Mike Melanson
    /* perform direct multiplication instead of series of jumps proposed by
715
     * the reference ADPCM implementation since modern CPUs can do the mults
716
     * quickly enough */
717 d94728c3 Michael Niedermayer
    diff = ((2 * delta + 1) * step) >> shift;
718 4b465299 Michael Niedermayer
    predictor = c->predictor;
719
    if (sign) predictor -= diff;
720
    else predictor += diff;
721
722 295f3737 Aurelien Jacobs
    c->predictor = av_clip_int16(predictor);
723 4b465299 Michael Niedermayer
    c->step_index = step_index;
724
725 295f3737 Aurelien Jacobs
    return (short)c->predictor;
726 4b465299 Michael Niedermayer
}
727
728 0147f198 François Revol
static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
729
{
730
    int predictor;
731
732 ff227126 Reimar Döffinger
    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
733 0147f198 François Revol
    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
734
735
    c->sample2 = c->sample1;
736 295f3737 Aurelien Jacobs
    c->sample1 = av_clip_int16(predictor);
737 6cf9d5eb Michael Niedermayer
    c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
738 0147f198 François Revol
    if (c->idelta < 16) c->idelta = 16;
739
740 295f3737 Aurelien Jacobs
    return c->sample1;
741 0147f198 François Revol
}
742
743 b3bfb299 Mike Melanson
static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
744
{
745
    int sign, delta, diff;
746
    int new_step;
747
748
    sign = nibble & 8;
749
    delta = nibble & 7;
750
    /* perform direct multiplication instead of series of jumps proposed by
751
     * the reference ADPCM implementation since modern CPUs can do the mults
752
     * quickly enough */
753
    diff = ((2 * delta + 1) * c->step) >> 3;
754
    /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
755 e4a50e6d Aurelien Jacobs
    c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
756
    c->predictor = av_clip_int16(c->predictor);
757 b3bfb299 Mike Melanson
    /* calculate new step and clamp it to range 511..32767 */
758 89150098 Stefan Gehrer
    new_step = (AdaptationTable[nibble & 7] * c->step) >> 8;
759 88e2d588 Aurelien Jacobs
    c->step = av_clip(new_step, 511, 32767);
760 b3bfb299 Mike Melanson
761 295f3737 Aurelien Jacobs
    return (short)c->predictor;
762 b3bfb299 Mike Melanson
}
763
764 2433f24f Aurelien Jacobs
static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
765
{
766
    int sign, delta, diff;
767
768
    sign = nibble & (1<<(size-1));
769
    delta = nibble & ((1<<(size-1))-1);
770
    diff = delta << (7 + c->step + shift);
771
772
    /* clamp result */
773 88e2d588 Aurelien Jacobs
    c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
774 2433f24f Aurelien Jacobs
775
    /* calculate new step */
776
    if (delta >= (2*size - 3) && c->step < 3)
777
        c->step++;
778
    else if (delta == 0 && c->step > 0)
779
        c->step--;
780
781
    return (short) c->predictor;
782
}
783
784 2ff4524e Vidar Madsen
static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
785
{
786
    if(!c->step) {
787
        c->predictor = 0;
788
        c->step = 127;
789
    }
790
791
    c->predictor += (c->step * yamaha_difflookup[nibble]) / 8;
792 aee481ce Aurelien Jacobs
    c->predictor = av_clip_int16(c->predictor);
793 2ff4524e Vidar Madsen
    c->step = (c->step * yamaha_indexscale[nibble]) >> 8;
794 f66e4f5f Reimar Döffinger
    c->step = av_clip(c->step, 127, 24567);
795 2ff4524e Vidar Madsen
    return c->predictor;
796
}
797
798 115329f1 Diego Biurrun
static void xa_decode(short *out, const unsigned char *in,
799 fc384777 Mike Melanson
    ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
800
{
801
    int i, j;
802
    int shift,filter,f0,f1;
803
    int s_1,s_2;
804
    int d,s,t;
805
806
    for(i=0;i<4;i++) {
807
808
        shift  = 12 - (in[4+i*2] & 15);
809
        filter = in[4+i*2] >> 4;
810
        f0 = xa_adpcm_table[filter][0];
811
        f1 = xa_adpcm_table[filter][1];
812
813
        s_1 = left->sample1;
814
        s_2 = left->sample2;
815
816
        for(j=0;j<28;j++) {
817
            d = in[16+i+j*4];
818
819
            t = (signed char)(d<<4)>>4;
820
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
821
            s_2 = s_1;
822 295f3737 Aurelien Jacobs
            s_1 = av_clip_int16(s);
823
            *out = s_1;
824
            out += inc;
825 fc384777 Mike Melanson
        }
826
827
        if (inc==2) { /* stereo */
828
            left->sample1 = s_1;
829
            left->sample2 = s_2;
830
            s_1 = right->sample1;
831
            s_2 = right->sample2;
832
            out = out + 1 - 28*2;
833
        }
834
835
        shift  = 12 - (in[5+i*2] & 15);
836
        filter = in[5+i*2] >> 4;
837
838
        f0 = xa_adpcm_table[filter][0];
839
        f1 = xa_adpcm_table[filter][1];
840
841
        for(j=0;j<28;j++) {
842
            d = in[16+i+j*4];
843
844
            t = (signed char)d >> 4;
845
            s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
846
            s_2 = s_1;
847 295f3737 Aurelien Jacobs
            s_1 = av_clip_int16(s);
848
            *out = s_1;
849
            out += inc;
850 fc384777 Mike Melanson
        }
851
852
        if (inc==2) { /* stereo */
853
            right->sample1 = s_1;
854
            right->sample2 = s_2;
855
            out -= 1;
856
        } else {
857
            left->sample1 = s_1;
858
            left->sample2 = s_2;
859
        }
860
    }
861
}
862
863
864 9937e686 Mike Melanson
/* DK3 ADPCM support macro */
865
#define DK3_GET_NEXT_NIBBLE() \
866
    if (decode_top_nibble_next) \
867
    { \
868 05adf49c Michael Niedermayer
        nibble = last_byte >> 4; \
869 9937e686 Mike Melanson
        decode_top_nibble_next = 0; \
870
    } \
871
    else \
872
    { \
873
        last_byte = *src++; \
874
        if (src >= buf + buf_size) break; \
875
        nibble = last_byte & 0x0F; \
876
        decode_top_nibble_next = 1; \
877
    }
878
879 0147f198 François Revol
static int adpcm_decode_frame(AVCodecContext *avctx,
880 bb270c08 Diego Biurrun
                            void *data, int *data_size,
881 7a00bbad Thilo Borgmann
                            AVPacket *avpkt)
882 0147f198 François Revol
{
883 7a00bbad Thilo Borgmann
    const uint8_t *buf = avpkt->data;
884
    int buf_size = avpkt->size;
885 0147f198 François Revol
    ADPCMContext *c = avctx->priv_data;
886
    ADPCMChannelStatus *cs;
887 4b465299 Michael Niedermayer
    int n, m, channel, i;
888 0147f198 François Revol
    int block_predictor[2];
889
    short *samples;
890 14c49573 Michael Niedermayer
    short *samples_end;
891 81ef51e6 Michael Niedermayer
    const uint8_t *src;
892 0147f198 François Revol
    int st; /* stereo */
893
894 9937e686 Mike Melanson
    /* DK3 ADPCM accounting variables */
895
    unsigned char last_byte = 0;
896
    unsigned char nibble;
897
    int decode_top_nibble_next = 0;
898
    int diff_channel;
899
900 7d8379f2 Mike Melanson
    /* EA ADPCM state variables */
901
    uint32_t samples_in_chunk;
902
    int32_t previous_left_sample, previous_right_sample;
903
    int32_t current_left_sample, current_right_sample;
904
    int32_t next_left_sample, next_right_sample;
905
    int32_t coeff1l, coeff2l, coeff1r, coeff2r;
906
    uint8_t shift_left, shift_right;
907
    int count1, count2;
908 861c63a2 Robert Marston
    int coeff[2][2], shift[2];//used in EA MAXIS ADPCM
909 7d8379f2 Mike Melanson
910 df72754d Mike Melanson
    if (!buf_size)
911
        return 0;
912
913 14c49573 Michael Niedermayer
    //should protect all 4bit ADPCM variants
914
    //8 is needed for CODEC_ID_ADPCM_IMA_WAV with 2 channels
915
    //
916
    if(*data_size/4 < buf_size + 8)
917
        return -1;
918
919 0147f198 François Revol
    samples = data;
920 14c49573 Michael Niedermayer
    samples_end= samples + *data_size/2;
921
    *data_size= 0;
922 0147f198 François Revol
    src = buf;
923
924 2433f24f Aurelien Jacobs
    st = avctx->channels == 2 ? 1 : 0;
925 0147f198 François Revol
926
    switch(avctx->codec->id) {
927
    case CODEC_ID_ADPCM_IMA_QT:
928 9ff8976d Baptiste Coudurier
        n = buf_size - 2*avctx->channels;
929
        for (channel = 0; channel < avctx->channels; channel++) {
930 3b4eccab Baptiste Coudurier
            cs = &(c->status[channel]);
931
            /* (pppppp) (piiiiiii) */
932 0147f198 François Revol
933 3b4eccab Baptiste Coudurier
            /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
934
            cs->predictor = (*src++) << 8;
935
            cs->predictor |= (*src & 0x80);
936
            cs->predictor &= 0xFF80;
937 0147f198 François Revol
938 3b4eccab Baptiste Coudurier
            /* sign extension */
939
            if(cs->predictor & 0x8000)
940
                cs->predictor -= 0x10000;
941 0147f198 François Revol
942 3b4eccab Baptiste Coudurier
            cs->predictor = av_clip_int16(cs->predictor);
943 0147f198 François Revol
944 3b4eccab Baptiste Coudurier
            cs->step_index = (*src++) & 0x7F;
945 0147f198 François Revol
946 3b4eccab Baptiste Coudurier
            if (cs->step_index > 88){
947
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
948
                cs->step_index = 88;
949
            }
950 0147f198 François Revol
951 3b4eccab Baptiste Coudurier
            cs->step = step_table[cs->step_index];
952 0147f198 François Revol
953 3b4eccab Baptiste Coudurier
            samples = (short*)data + channel;
954 0147f198 François Revol
955 3b4eccab Baptiste Coudurier
            for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
956
                *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3);
957
                samples += avctx->channels;
958
                *samples = adpcm_ima_expand_nibble(cs, src[0] >> 4  , 3);
959
                samples += avctx->channels;
960
                src ++;
961
            }
962 0147f198 François Revol
        }
963 9ff8976d Baptiste Coudurier
        if (st)
964
            samples--;
965 0147f198 François Revol
        break;
966
    case CODEC_ID_ADPCM_IMA_WAV:
967 ca1d62f4 Assaf Yaari
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
968
            buf_size = avctx->block_align;
969
970 8d359bba Michael Niedermayer
//        samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1;
971
972 d94728c3 Michael Niedermayer
        for(i=0; i<avctx->channels; i++){
973
            cs = &(c->status[i]);
974 962fe7e1 Reimar Döffinger
            cs->predictor = *samples++ = (int16_t)bytestream_get_le16(&src);
975 0147f198 François Revol
976 d94728c3 Michael Niedermayer
            cs->step_index = *src++;
977 8d359bba Michael Niedermayer
            if (cs->step_index > 88){
978
                av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
979
                cs->step_index = 88;
980
            }
981
            if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */
982 0147f198 François Revol
        }
983
984 8d359bba Michael Niedermayer
        while(src < buf + buf_size){
985
            for(m=0; m<4; m++){
986
                for(i=0; i<=st; i++)
987
                    *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3);
988
                for(i=0; i<=st; i++)
989
                    *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4  , 3);
990
                src++;
991 bb270c08 Diego Biurrun
            }
992 8d359bba Michael Niedermayer
            src += 4*st;
993 bb270c08 Diego Biurrun
        }
994 0147f198 François Revol
        break;
995 4b465299 Michael Niedermayer
    case CODEC_ID_ADPCM_4XM:
996
        cs = &(c->status[0]);
997 962fe7e1 Reimar Döffinger
        c->status[0].predictor= (int16_t)bytestream_get_le16(&src);
998 4b465299 Michael Niedermayer
        if(st){
999 962fe7e1 Reimar Döffinger
            c->status[1].predictor= (int16_t)bytestream_get_le16(&src);
1000 4b465299 Michael Niedermayer
        }
1001 962fe7e1 Reimar Döffinger
        c->status[0].step_index= (int16_t)bytestream_get_le16(&src);
1002 4b465299 Michael Niedermayer
        if(st){
1003 962fe7e1 Reimar Döffinger
            c->status[1].step_index= (int16_t)bytestream_get_le16(&src);
1004 4b465299 Michael Niedermayer
        }
1005 ac3d5cac Mike Melanson
        if (cs->step_index < 0) cs->step_index = 0;
1006
        if (cs->step_index > 88) cs->step_index = 88;
1007 4b465299 Michael Niedermayer
1008
        m= (buf_size - (src - buf))>>st;
1009
        for(i=0; i<m; i++) {
1010 bb270c08 Diego Biurrun
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);
1011 4b465299 Michael Niedermayer
            if (st)
1012 d94728c3 Michael Niedermayer
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);
1013
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);
1014 bb270c08 Diego Biurrun
            if (st)
1015 d94728c3 Michael Niedermayer
                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);
1016 bb270c08 Diego Biurrun
        }
1017 4b465299 Michael Niedermayer
1018
        src += m<<st;
1019
1020
        break;
1021 0147f198 François Revol
    case CODEC_ID_ADPCM_MS:
1022 ca1d62f4 Assaf Yaari
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
1023
            buf_size = avctx->block_align;
1024 0147f198 François Revol
        n = buf_size - 7 * avctx->channels;
1025
        if (n < 0)
1026
            return -1;
1027 f9bd3056 Reimar Döffinger
        block_predictor[0] = av_clip(*src++, 0, 6);
1028 0147f198 François Revol
        block_predictor[1] = 0;
1029
        if (st)
1030 f9bd3056 Reimar Döffinger
            block_predictor[1] = av_clip(*src++, 0, 6);
1031 962fe7e1 Reimar Döffinger
        c->status[0].idelta = (int16_t)bytestream_get_le16(&src);
1032 6cf9d5eb Michael Niedermayer
        if (st){
1033 962fe7e1 Reimar Döffinger
            c->status[1].idelta = (int16_t)bytestream_get_le16(&src);
1034 6cf9d5eb Michael Niedermayer
        }
1035 0147f198 François Revol
        c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
1036
        c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
1037
        c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
1038
        c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
1039 115329f1 Diego Biurrun
1040 962fe7e1 Reimar Döffinger
        c->status[0].sample1 = bytestream_get_le16(&src);
1041
        if (st) c->status[1].sample1 = bytestream_get_le16(&src);
1042
        c->status[0].sample2 = bytestream_get_le16(&src);
1043
        if (st) c->status[1].sample2 = bytestream_get_le16(&src);
1044 0147f198 François Revol
1045
        *samples++ = c->status[0].sample2;
1046
        if (st) *samples++ = c->status[1].sample2;
1047 ae8afab9 Reimar Döffinger
        *samples++ = c->status[0].sample1;
1048
        if (st) *samples++ = c->status[1].sample1;
1049 0147f198 François Revol
        for(;n>0;n--) {
1050 05adf49c Michael Niedermayer
            *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], src[0] >> 4  );
1051 0147f198 François Revol
            *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
1052
            src ++;
1053
        }
1054
        break;
1055 9937e686 Mike Melanson
    case CODEC_ID_ADPCM_IMA_DK4:
1056 5c69a4fd Michael Niedermayer
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
1057
            buf_size = avctx->block_align;
1058
1059 962fe7e1 Reimar Döffinger
        c->status[0].predictor  = (int16_t)bytestream_get_le16(&src);
1060
        c->status[0].step_index = *src++;
1061
        src++;
1062 9937e686 Mike Melanson
        *samples++ = c->status[0].predictor;
1063
        if (st) {
1064 962fe7e1 Reimar Döffinger
            c->status[1].predictor  = (int16_t)bytestream_get_le16(&src);
1065
            c->status[1].step_index = *src++;
1066
            src++;
1067 9937e686 Mike Melanson
            *samples++ = c->status[1].predictor;
1068
        }
1069
        while (src < buf + buf_size) {
1070
1071
            /* take care of the top nibble (always left or mono channel) */
1072 115329f1 Diego Biurrun
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1073 05adf49c Michael Niedermayer
                src[0] >> 4, 3);
1074 9937e686 Mike Melanson
1075
            /* take care of the bottom nibble, which is right sample for
1076
             * stereo, or another mono sample */
1077
            if (st)
1078 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[1],
1079 d94728c3 Michael Niedermayer
                    src[0] & 0x0F, 3);
1080 9937e686 Mike Melanson
            else
1081 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1082 d94728c3 Michael Niedermayer
                    src[0] & 0x0F, 3);
1083 9937e686 Mike Melanson
1084
            src++;
1085
        }
1086
        break;
1087
    case CODEC_ID_ADPCM_IMA_DK3:
1088 5c69a4fd Michael Niedermayer
        if (avctx->block_align != 0 && buf_size > avctx->block_align)
1089
            buf_size = avctx->block_align;
1090
1091 14c49573 Michael Niedermayer
        if(buf_size + 16 > (samples_end - samples)*3/8)
1092
            return -1;
1093
1094 962fe7e1 Reimar Döffinger
        c->status[0].predictor  = (int16_t)AV_RL16(src + 10);
1095
        c->status[1].predictor  = (int16_t)AV_RL16(src + 12);
1096 9937e686 Mike Melanson
        c->status[0].step_index = src[14];
1097
        c->status[1].step_index = src[15];
1098
        /* sign extend the predictors */
1099
        src += 16;
1100
        diff_channel = c->status[1].predictor;
1101
1102
        /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
1103
         * the buffer is consumed */
1104
        while (1) {
1105
1106
            /* for this algorithm, c->status[0] is the sum channel and
1107
             * c->status[1] is the diff channel */
1108
1109
            /* process the first predictor of the sum channel */
1110
            DK3_GET_NEXT_NIBBLE();
1111 d94728c3 Michael Niedermayer
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1112 9937e686 Mike Melanson
1113
            /* process the diff channel predictor */
1114
            DK3_GET_NEXT_NIBBLE();
1115 d94728c3 Michael Niedermayer
            adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
1116 9937e686 Mike Melanson
1117
            /* process the first pair of stereo PCM samples */
1118
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
1119
            *samples++ = c->status[0].predictor + c->status[1].predictor;
1120
            *samples++ = c->status[0].predictor - c->status[1].predictor;
1121
1122
            /* process the second predictor of the sum channel */
1123
            DK3_GET_NEXT_NIBBLE();
1124 d94728c3 Michael Niedermayer
            adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1125 9937e686 Mike Melanson
1126
            /* process the second pair of stereo PCM samples */
1127
            diff_channel = (diff_channel + c->status[1].predictor) / 2;
1128
            *samples++ = c->status[0].predictor + c->status[1].predictor;
1129
            *samples++ = c->status[0].predictor - c->status[1].predictor;
1130
        }
1131
        break;
1132 055dc116 Stefan Gehrer
    case CODEC_ID_ADPCM_IMA_ISS:
1133
        c->status[0].predictor  = (int16_t)AV_RL16(src + 0);
1134
        c->status[0].step_index = src[2];
1135
        src += 4;
1136
        if(st) {
1137
            c->status[1].predictor  = (int16_t)AV_RL16(src + 0);
1138
            c->status[1].step_index = src[2];
1139
            src += 4;
1140
        }
1141
1142
        while (src < buf + buf_size) {
1143
1144
            if (st) {
1145
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1146
                    src[0] >> 4  , 3);
1147
                *samples++ = adpcm_ima_expand_nibble(&c->status[1],
1148
                    src[0] & 0x0F, 3);
1149
            } else {
1150
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1151
                    src[0] & 0x0F, 3);
1152
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1153
                    src[0] >> 4  , 3);
1154
            }
1155
1156
            src++;
1157
        }
1158
        break;
1159 2fdf638b Mike Melanson
    case CODEC_ID_ADPCM_IMA_WS:
1160
        /* no per-block initialization; just start decoding the data */
1161
        while (src < buf + buf_size) {
1162
1163
            if (st) {
1164 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1165 05adf49c Michael Niedermayer
                    src[0] >> 4  , 3);
1166 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[1],
1167 d94728c3 Michael Niedermayer
                    src[0] & 0x0F, 3);
1168 2fdf638b Mike Melanson
            } else {
1169 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1170 05adf49c Michael Niedermayer
                    src[0] >> 4  , 3);
1171 115329f1 Diego Biurrun
                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1172 d94728c3 Michael Niedermayer
                    src[0] & 0x0F, 3);
1173 2fdf638b Mike Melanson
            }
1174
1175
            src++;
1176
        }
1177
        break;
1178 fc384777 Mike Melanson
    case CODEC_ID_ADPCM_XA:
1179
        while (buf_size >= 128) {
1180 115329f1 Diego Biurrun
            xa_decode(samples, src, &c->status[0], &c->status[1],
1181 fc384777 Mike Melanson
                avctx->channels);
1182
            src += 128;
1183
            samples += 28 * 8;
1184
            buf_size -= 128;
1185
        }
1186
        break;
1187 fac84d3c Peter Ross
    case CODEC_ID_ADPCM_IMA_EA_EACS:
1188
        samples_in_chunk = bytestream_get_le32(&src) >> (1-st);
1189
1190
        if (samples_in_chunk > buf_size-4-(8<<st)) {
1191
            src += buf_size - 4;
1192
            break;
1193
        }
1194
1195
        for (i=0; i<=st; i++)
1196
            c->status[i].step_index = bytestream_get_le32(&src);
1197
        for (i=0; i<=st; i++)
1198
            c->status[i].predictor  = bytestream_get_le32(&src);
1199
1200
        for (; samples_in_chunk; samples_in_chunk--, src++) {
1201
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  *src>>4,   3);
1202
            *samples++ = adpcm_ima_expand_nibble(&c->status[st], *src&0x0F, 3);
1203
        }
1204
        break;
1205 7bb65d89 Peter Ross
    case CODEC_ID_ADPCM_IMA_EA_SEAD:
1206
        for (; src < buf+buf_size; src++) {
1207
            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] >> 4, 6);
1208
            *samples++ = adpcm_ima_expand_nibble(&c->status[st],src[0]&0x0F, 6);
1209
        }
1210
        break;
1211 7d8379f2 Mike Melanson
    case CODEC_ID_ADPCM_EA:
1212 fead30d4 Alex Beregszaszi
        samples_in_chunk = AV_RL32(src);
1213 7d8379f2 Mike Melanson
        if (samples_in_chunk >= ((buf_size - 12) * 2)) {
1214
            src += buf_size;
1215
            break;
1216
        }
1217
        src += 4;
1218 962fe7e1 Reimar Döffinger
        current_left_sample   = (int16_t)bytestream_get_le16(&src);
1219
        previous_left_sample  = (int16_t)bytestream_get_le16(&src);
1220
        current_right_sample  = (int16_t)bytestream_get_le16(&src);
1221
        previous_right_sample = (int16_t)bytestream_get_le16(&src);
1222 7d8379f2 Mike Melanson
1223
        for (count1 = 0; count1 < samples_in_chunk/28;count1++) {
1224 05adf49c Michael Niedermayer
            coeff1l = ea_adpcm_table[ *src >> 4       ];
1225
            coeff2l = ea_adpcm_table[(*src >> 4  ) + 4];
1226 7d8379f2 Mike Melanson
            coeff1r = ea_adpcm_table[*src & 0x0F];
1227
            coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
1228
            src++;
1229
1230 05adf49c Michael Niedermayer
            shift_left  = (*src >> 4  ) + 8;
1231 7d8379f2 Mike Melanson
            shift_right = (*src & 0x0F) + 8;
1232
            src++;
1233
1234
            for (count2 = 0; count2 < 28; count2++) {
1235 8c2a4ddc Michael Niedermayer
                next_left_sample  = (int32_t)((*src & 0xF0) << 24) >> shift_left;
1236
                next_right_sample = (int32_t)((*src & 0x0F) << 28) >> shift_right;
1237 7d8379f2 Mike Melanson
                src++;
1238
1239 115329f1 Diego Biurrun
                next_left_sample = (next_left_sample +
1240
                    (current_left_sample * coeff1l) +
1241 7d8379f2 Mike Melanson
                    (previous_left_sample * coeff2l) + 0x80) >> 8;
1242 115329f1 Diego Biurrun
                next_right_sample = (next_right_sample +
1243
                    (current_right_sample * coeff1r) +
1244 7d8379f2 Mike Melanson
                    (previous_right_sample * coeff2r) + 0x80) >> 8;
1245
1246
                previous_left_sample = current_left_sample;
1247 295f3737 Aurelien Jacobs
                current_left_sample = av_clip_int16(next_left_sample);
1248 7d8379f2 Mike Melanson
                previous_right_sample = current_right_sample;
1249 295f3737 Aurelien Jacobs
                current_right_sample = av_clip_int16(next_right_sample);
1250 7d8379f2 Mike Melanson
                *samples++ = (unsigned short)current_left_sample;
1251
                *samples++ = (unsigned short)current_right_sample;
1252
            }
1253
        }
1254
        break;
1255 861c63a2 Robert Marston
    case CODEC_ID_ADPCM_EA_MAXIS_XA:
1256
        for(channel = 0; channel < avctx->channels; channel++) {
1257
            for (i=0; i<2; i++)
1258
                coeff[channel][i] = ea_adpcm_table[(*src >> 4) + 4*i];
1259
            shift[channel] = (*src & 0x0F) + 8;
1260
            src++;
1261
        }
1262
        for (count1 = 0; count1 < (buf_size - avctx->channels) / avctx->channels; count1++) {
1263
            for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
1264
                for(channel = 0; channel < avctx->channels; channel++) {
1265
                    int32_t sample = (int32_t)(((*(src+channel) >> i) & 0x0F) << 0x1C) >> shift[channel];
1266
                    sample = (sample +
1267
                             c->status[channel].sample1 * coeff[channel][0] +
1268
                             c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
1269
                    c->status[channel].sample2 = c->status[channel].sample1;
1270
                    c->status[channel].sample1 = av_clip_int16(sample);
1271
                    *samples++ = c->status[channel].sample1;
1272
                }
1273
            }
1274
            src+=avctx->channels;
1275
        }
1276
        break;
1277 e7583962 Peter Ross
    case CODEC_ID_ADPCM_EA_R1:
1278
    case CODEC_ID_ADPCM_EA_R2:
1279
    case CODEC_ID_ADPCM_EA_R3: {
1280
        /* channel numbering
1281
           2chan: 0=fl, 1=fr
1282
           4chan: 0=fl, 1=rl, 2=fr, 3=rr
1283
           6chan: 0=fl, 1=c,  2=fr, 3=rl,  4=rr, 5=sub */
1284
        const int big_endian = avctx->codec->id == CODEC_ID_ADPCM_EA_R3;
1285
        int32_t previous_sample, current_sample, next_sample;
1286
        int32_t coeff1, coeff2;
1287
        uint8_t shift;
1288
        unsigned int channel;
1289
        uint16_t *samplesC;
1290 81ef51e6 Michael Niedermayer
        const uint8_t *srcC;
1291 cc55c464 Stefan Gehrer
        const uint8_t *src_end = buf + buf_size;
1292 e7583962 Peter Ross
1293
        samples_in_chunk = (big_endian ? bytestream_get_be32(&src)
1294
                                       : bytestream_get_le32(&src)) / 28;
1295
        if (samples_in_chunk > UINT32_MAX/(28*avctx->channels) ||
1296
            28*samples_in_chunk*avctx->channels > samples_end-samples) {
1297
            src += buf_size - 4;
1298
            break;
1299
        }
1300
1301
        for (channel=0; channel<avctx->channels; channel++) {
1302 cc55c464 Stefan Gehrer
            int32_t offset = (big_endian ? bytestream_get_be32(&src)
1303
                                         : bytestream_get_le32(&src))
1304
                           + (avctx->channels-channel-1) * 4;
1305
1306
            if ((offset < 0) || (offset >= src_end - src - 4)) break;
1307
            srcC  = src + offset;
1308 e7583962 Peter Ross
            samplesC = samples + channel;
1309
1310
            if (avctx->codec->id == CODEC_ID_ADPCM_EA_R1) {
1311
                current_sample  = (int16_t)bytestream_get_le16(&srcC);
1312
                previous_sample = (int16_t)bytestream_get_le16(&srcC);
1313
            } else {
1314
                current_sample  = c->status[channel].predictor;
1315
                previous_sample = c->status[channel].prev_sample;
1316
            }
1317
1318
            for (count1=0; count1<samples_in_chunk; count1++) {
1319
                if (*srcC == 0xEE) {  /* only seen in R2 and R3 */
1320
                    srcC++;
1321 cc55c464 Stefan Gehrer
                    if (srcC > src_end - 30*2) break;
1322 e7583962 Peter Ross
                    current_sample  = (int16_t)bytestream_get_be16(&srcC);
1323
                    previous_sample = (int16_t)bytestream_get_be16(&srcC);
1324
1325
                    for (count2=0; count2<28; count2++) {
1326
                        *samplesC = (int16_t)bytestream_get_be16(&srcC);
1327
                        samplesC += avctx->channels;
1328
                    }
1329
                } else {
1330 05adf49c Michael Niedermayer
                    coeff1 = ea_adpcm_table[ *srcC>>4     ];
1331
                    coeff2 = ea_adpcm_table[(*srcC>>4) + 4];
1332 e7583962 Peter Ross
                    shift = (*srcC++ & 0x0F) + 8;
1333
1334 cc55c464 Stefan Gehrer
                    if (srcC > src_end - 14) break;
1335 e7583962 Peter Ross
                    for (count2=0; count2<28; count2++) {
1336
                        if (count2 & 1)
1337 8c2a4ddc Michael Niedermayer
                            next_sample = (int32_t)((*srcC++ & 0x0F) << 28) >> shift;
1338 e7583962 Peter Ross
                        else
1339 8c2a4ddc Michael Niedermayer
                            next_sample = (int32_t)((*srcC   & 0xF0) << 24) >> shift;
1340 e7583962 Peter Ross
1341
                        next_sample += (current_sample  * coeff1) +
1342
                                       (previous_sample * coeff2);
1343
                        next_sample = av_clip_int16(next_sample >> 8);
1344
1345
                        previous_sample = current_sample;
1346
                        current_sample  = next_sample;
1347
                        *samplesC = current_sample;
1348
                        samplesC += avctx->channels;
1349
                    }
1350
                }
1351
            }
1352
1353
            if (avctx->codec->id != CODEC_ID_ADPCM_EA_R1) {
1354
                c->status[channel].predictor   = current_sample;
1355
                c->status[channel].prev_sample = previous_sample;
1356
            }
1357
        }
1358
1359
        src = src + buf_size - (4 + 4*avctx->channels);
1360
        samples += 28 * samples_in_chunk * avctx->channels;
1361
        break;
1362
    }
1363 271b4095 Aurelien Jacobs
    case CODEC_ID_ADPCM_EA_XAS:
1364
        if (samples_end-samples < 32*4*avctx->channels
1365
            || buf_size < (4+15)*4*avctx->channels) {
1366
            src += buf_size;
1367
            break;
1368
        }
1369
        for (channel=0; channel<avctx->channels; channel++) {
1370
            int coeff[2][4], shift[4];
1371
            short *s2, *s = &samples[channel];
1372
            for (n=0; n<4; n++, s+=32*avctx->channels) {
1373
                for (i=0; i<2; i++)
1374
                    coeff[i][n] = ea_adpcm_table[(src[0]&0x0F)+4*i];
1375
                shift[n] = (src[2]&0x0F) + 8;
1376
                for (s2=s, i=0; i<2; i++, src+=2, s2+=avctx->channels)
1377
                    s2[0] = (src[0]&0xF0) + (src[1]<<8);
1378
            }
1379
1380
            for (m=2; m<32; m+=2) {
1381
                s = &samples[m*avctx->channels + channel];
1382
                for (n=0; n<4; n++, src++, s+=32*avctx->channels) {
1383
                    for (s2=s, i=0; i<8; i+=4, s2+=avctx->channels) {
1384 8c2a4ddc Michael Niedermayer
                        int level = (int32_t)((*src & (0xF0>>i)) << (24+i)) >> shift[n];
1385 271b4095 Aurelien Jacobs
                        int pred  = s2[-1*avctx->channels] * coeff[0][n]
1386
                                  + s2[-2*avctx->channels] * coeff[1][n];
1387
                        s2[0] = av_clip_int16((level + pred + 0x80) >> 8);
1388
                    }
1389
                }
1390
            }
1391
        }
1392
        samples += 32*4*avctx->channels;
1393
        break;
1394 3a7f5d07 Vitor Sessak
    case CODEC_ID_ADPCM_IMA_AMV:
1395 7d8379f2 Mike Melanson
    case CODEC_ID_ADPCM_IMA_SMJPEG:
1396 94d9633a Vladimir Voroshilov
        c->status[0].predictor = (int16_t)bytestream_get_le16(&src);
1397 330194b9 Vladimir Voroshilov
        c->status[0].step_index = bytestream_get_le16(&src);
1398 3a7f5d07 Vitor Sessak
1399
        if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV)
1400
            src+=4;
1401
1402 7d8379f2 Mike Melanson
        while (src < buf + buf_size) {
1403 3a7f5d07 Vitor Sessak
            char hi, lo;
1404
            lo = *src & 0x0F;
1405 05adf49c Michael Niedermayer
            hi = *src >> 4;
1406 3a7f5d07 Vitor Sessak
1407
            if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV)
1408
                FFSWAP(char, hi, lo);
1409
1410 7d8379f2 Mike Melanson
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1411 3a7f5d07 Vitor Sessak
                lo, 3);
1412 7d8379f2 Mike Melanson
            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1413 3a7f5d07 Vitor Sessak
                hi, 3);
1414 7d8379f2 Mike Melanson
            src++;
1415
        }
1416
        break;
1417 b3bfb299 Mike Melanson
    case CODEC_ID_ADPCM_CT:
1418 bb270c08 Diego Biurrun
        while (src < buf + buf_size) {
1419 b3bfb299 Mike Melanson
            if (st) {
1420 115329f1 Diego Biurrun
                *samples++ = adpcm_ct_expand_nibble(&c->status[0],
1421 05adf49c Michael Niedermayer
                    src[0] >> 4);
1422 115329f1 Diego Biurrun
                *samples++ = adpcm_ct_expand_nibble(&c->status[1],
1423 b3bfb299 Mike Melanson
                    src[0] & 0x0F);
1424
            } else {
1425 115329f1 Diego Biurrun
                *samples++ = adpcm_ct_expand_nibble(&c->status[0],
1426 05adf49c Michael Niedermayer
                    src[0] >> 4);
1427 115329f1 Diego Biurrun
                *samples++ = adpcm_ct_expand_nibble(&c->status[0],
1428 b3bfb299 Mike Melanson
                    src[0] & 0x0F);
1429
            }
1430 bb270c08 Diego Biurrun
            src++;
1431 b3bfb299 Mike Melanson
        }
1432
        break;
1433 2433f24f Aurelien Jacobs
    case CODEC_ID_ADPCM_SBPRO_4:
1434
    case CODEC_ID_ADPCM_SBPRO_3:
1435
    case CODEC_ID_ADPCM_SBPRO_2:
1436
        if (!c->status[0].step_index) {
1437
            /* the first byte is a raw sample */
1438
            *samples++ = 128 * (*src++ - 0x80);
1439
            if (st)
1440
              *samples++ = 128 * (*src++ - 0x80);
1441
            c->status[0].step_index = 1;
1442
        }
1443
        if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) {
1444
            while (src < buf + buf_size) {
1445
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1446 05adf49c Michael Niedermayer
                    src[0] >> 4, 4, 0);
1447 2433f24f Aurelien Jacobs
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1448
                    src[0] & 0x0F, 4, 0);
1449
                src++;
1450
            }
1451
        } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) {
1452 14c49573 Michael Niedermayer
            while (src < buf + buf_size && samples + 2 < samples_end) {
1453 2433f24f Aurelien Jacobs
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1454 05adf49c Michael Niedermayer
                     src[0] >> 5        , 3, 0);
1455 2433f24f Aurelien Jacobs
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1456
                    (src[0] >> 2) & 0x07, 3, 0);
1457
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1458
                    src[0] & 0x03, 2, 0);
1459
                src++;
1460
            }
1461
        } else {
1462 14c49573 Michael Niedermayer
            while (src < buf + buf_size && samples + 3 < samples_end) {
1463 2433f24f Aurelien Jacobs
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1464 05adf49c Michael Niedermayer
                     src[0] >> 6        , 2, 2);
1465 2433f24f Aurelien Jacobs
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1466
                    (src[0] >> 4) & 0x03, 2, 2);
1467
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1468
                    (src[0] >> 2) & 0x03, 2, 2);
1469
                *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1470
                    src[0] & 0x03, 2, 2);
1471
                src++;
1472
            }
1473
        }
1474
        break;
1475 659c3692 Alex Beregszaszi
    case CODEC_ID_ADPCM_SWF:
1476
    {
1477 bb270c08 Diego Biurrun
        GetBitContext gb;
1478
        const int *table;
1479 fe4ff07a Baptiste Coudurier
        int k0, signmask, nb_bits, count;
1480 bb270c08 Diego Biurrun
        int size = buf_size*8;
1481
1482
        init_get_bits(&gb, buf, size);
1483
1484 90b5b51e Diego Biurrun
        //read bits & initial values
1485 387afa9d Baptiste Coudurier
        nb_bits = get_bits(&gb, 2)+2;
1486
        //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits);
1487
        table = swf_index_tables[nb_bits-2];
1488
        k0 = 1 << (nb_bits-2);
1489
        signmask = 1 << (nb_bits-1);
1490 bb270c08 Diego Biurrun
1491 fe4ff07a Baptiste Coudurier
        while (get_bits_count(&gb) <= size - 22*avctx->channels) {
1492 387afa9d Baptiste Coudurier
            for (i = 0; i < avctx->channels; i++) {
1493 d0fa156f Baptiste Coudurier
                *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
1494
                c->status[i].step_index = get_bits(&gb, 6);
1495
            }
1496
1497
            for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
1498
                int i;
1499
1500
                for (i = 0; i < avctx->channels; i++) {
1501
                    // similar to IMA adpcm
1502
                    int delta = get_bits(&gb, nb_bits);
1503
                    int step = step_table[c->status[i].step_index];
1504
                    long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
1505
                    int k = k0;
1506
1507
                    do {
1508
                        if (delta & k)
1509
                            vpdiff += step;
1510
                        step >>= 1;
1511
                        k >>= 1;
1512
                    } while(k);
1513
                    vpdiff += step;
1514
1515
                    if (delta & signmask)
1516
                        c->status[i].predictor -= vpdiff;
1517
                    else
1518
                        c->status[i].predictor += vpdiff;
1519
1520
                    c->status[i].step_index += table[delta & (~signmask)];
1521
1522
                    c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
1523 aee481ce Aurelien Jacobs
                    c->status[i].predictor = av_clip_int16(c->status[i].predictor);
1524 d0fa156f Baptiste Coudurier
1525
                    *samples++ = c->status[i].predictor;
1526
                    if (samples >= samples_end) {
1527
                        av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");
1528
                        return -1;
1529
                    }
1530 387afa9d Baptiste Coudurier
                }
1531 bb270c08 Diego Biurrun
            }
1532
        }
1533 387afa9d Baptiste Coudurier
        src += buf_size;
1534 bb270c08 Diego Biurrun
        break;
1535 659c3692 Alex Beregszaszi
    }
1536 2ff4524e Vidar Madsen
    case CODEC_ID_ADPCM_YAMAHA:
1537
        while (src < buf + buf_size) {
1538
            if (st) {
1539
                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
1540
                        src[0] & 0x0F);
1541 b194c327 Michael Niedermayer
                *samples++ = adpcm_yamaha_expand_nibble(&c->status[1],
1542 05adf49c Michael Niedermayer
                        src[0] >> 4  );
1543 b194c327 Michael Niedermayer
            } else {
1544 2ff4524e Vidar Madsen
                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
1545
                        src[0] & 0x0F);
1546 b194c327 Michael Niedermayer
                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
1547 05adf49c Michael Niedermayer
                        src[0] >> 4  );
1548 2ff4524e Vidar Madsen
            }
1549
            src++;
1550
        }
1551
        break;
1552 d1e0d21f Marco Gerards
    case CODEC_ID_ADPCM_THP:
1553 90f2a1a0 Marco Gerards
    {
1554 20f75707 Michael Niedermayer
        int table[2][16];
1555 d1e0d21f Marco Gerards
        unsigned int samplecnt;
1556 b736a365 Michael Niedermayer
        int prev[2][2];
1557 d1e0d21f Marco Gerards
        int ch;
1558
1559
        if (buf_size < 80) {
1560
            av_log(avctx, AV_LOG_ERROR, "frame too small\n");
1561
            return -1;
1562
        }
1563
1564 949ed6bb Michael Niedermayer
        src+=4;
1565
        samplecnt = bytestream_get_be32(&src);
1566 d1e0d21f Marco Gerards
1567 11d66266 Michael Niedermayer
        for (i = 0; i < 32; i++)
1568 949ed6bb Michael Niedermayer
            table[0][i] = (int16_t)bytestream_get_be16(&src);
1569 d1e0d21f Marco Gerards
1570
        /* Initialize the previous sample.  */
1571 204424a4 Michael Niedermayer
        for (i = 0; i < 4; i++)
1572 949ed6bb Michael Niedermayer
            prev[0][i] = (int16_t)bytestream_get_be16(&src);
1573 d1e0d21f Marco Gerards
1574
        if (samplecnt >= (samples_end - samples) /  (st + 1)) {
1575
            av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");
1576
            return -1;
1577
        }
1578
1579
        for (ch = 0; ch <= st; ch++) {
1580
            samples = (unsigned short *) data + ch;
1581
1582
            /* Read in every sample for this channel.  */
1583
            for (i = 0; i < samplecnt / 14; i++) {
1584 949ed6bb Michael Niedermayer
                int index = (*src >> 4) & 7;
1585
                unsigned int exp = 28 - (*src++ & 15);
1586 20f75707 Michael Niedermayer
                int factor1 = table[ch][index * 2];
1587
                int factor2 = table[ch][index * 2 + 1];
1588 d1e0d21f Marco Gerards
1589
                /* Decode 14 samples.  */
1590
                for (n = 0; n < 14; n++) {
1591 949ed6bb Michael Niedermayer
                    int32_t sampledat;
1592
                    if(n&1) sampledat=  *src++    <<28;
1593
                    else    sampledat= (*src&0xF0)<<24;
1594 d1e0d21f Marco Gerards
1595 e457023a Marco Gerards
                    sampledat = ((prev[ch][0]*factor1
1596 949ed6bb Michael Niedermayer
                                + prev[ch][1]*factor2) >> 11) + (sampledat>>exp);
1597 295f3737 Aurelien Jacobs
                    *samples = av_clip_int16(sampledat);
1598 b736a365 Michael Niedermayer
                    prev[ch][1] = prev[ch][0];
1599
                    prev[ch][0] = *samples++;
1600 d1e0d21f Marco Gerards
1601
                    /* In case of stereo, skip one sample, this sample
1602
                       is for the other channel.  */
1603
                    samples += st;
1604
                }
1605
            }
1606
        }
1607
1608
        /* In the previous loop, in case stereo is used, samples is
1609
           increased exactly one time too often.  */
1610
        samples -= st;
1611
        break;
1612 90f2a1a0 Marco Gerards
    }
1613 d1e0d21f Marco Gerards
1614 0147f198 François Revol
    default:
1615
        return -1;
1616
    }
1617 0c1a9eda Zdenek Kabelac
    *data_size = (uint8_t *)samples - (uint8_t *)data;
1618 0147f198 François Revol
    return src - buf;
1619
}
1620
1621 764ef400 Mike Melanson
1622
1623 b250f9c6 Aurelien Jacobs
#if CONFIG_ENCODERS
1624 d349334a Diego Biurrun
#define ADPCM_ENCODER(id,name,long_name_)       \
1625 0147f198 François Revol
AVCodec name ## _encoder = {                    \
1626
    #name,                                      \
1627
    CODEC_TYPE_AUDIO,                           \
1628
    id,                                         \
1629
    sizeof(ADPCMContext),                       \
1630
    adpcm_encode_init,                          \
1631
    adpcm_encode_frame,                         \
1632
    adpcm_encode_close,                         \
1633
    NULL,                                       \
1634 fd76c37f Peter Ross
    .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE}, \
1635 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
1636 764ef400 Mike Melanson
};
1637
#else
1638 d349334a Diego Biurrun
#define ADPCM_ENCODER(id,name,long_name_)
1639 764ef400 Mike Melanson
#endif
1640
1641 b250f9c6 Aurelien Jacobs
#if CONFIG_DECODERS
1642 d349334a Diego Biurrun
#define ADPCM_DECODER(id,name,long_name_)       \
1643 0147f198 François Revol
AVCodec name ## _decoder = {                    \
1644
    #name,                                      \
1645
    CODEC_TYPE_AUDIO,                           \
1646
    id,                                         \
1647
    sizeof(ADPCMContext),                       \
1648
    adpcm_decode_init,                          \
1649
    NULL,                                       \
1650
    NULL,                                       \
1651
    adpcm_decode_frame,                         \
1652 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
1653 0147f198 François Revol
};
1654 764ef400 Mike Melanson
#else
1655 d349334a Diego Biurrun
#define ADPCM_DECODER(id,name,long_name_)
1656 764ef400 Mike Melanson
#endif
1657
1658 d349334a Diego Biurrun
#define ADPCM_CODEC(id,name,long_name_)         \
1659
    ADPCM_ENCODER(id,name,long_name_) ADPCM_DECODER(id,name,long_name_)
1660
1661 bbdfa06d Diego Biurrun
/* Note: Do not forget to add new entries to the Makefile as well. */
1662 fd75cedd Diego Biurrun
ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm, "ADPCM 4X Movie");
1663
ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct, "ADPCM Creative Technology");
1664
ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea, "ADPCM Electronic Arts");
1665
ADPCM_DECODER(CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");
1666
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "ADPCM Electronic Arts R1");
1667
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "ADPCM Electronic Arts R2");
1668
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3");
1669
ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS");
1670
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV");
1671
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3");
1672
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4");
1673
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");
1674
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");
1675
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_ISS, adpcm_ima_iss, "ADPCM IMA Funcom ISS");
1676
ADPCM_CODEC  (CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
1677
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");
1678
ADPCM_CODEC  (CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
1679
ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "ADPCM IMA Westwood");
1680
ADPCM_CODEC  (CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
1681
ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");
1682
ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");
1683
ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");
1684
ADPCM_CODEC  (CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
1685
ADPCM_DECODER(CODEC_ID_ADPCM_THP, adpcm_thp, "ADPCM Nintendo Gamecube THP");
1686
ADPCM_DECODER(CODEC_ID_ADPCM_XA, adpcm_xa, "ADPCM CDROM XA");
1687
ADPCM_CODEC  (CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");