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