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