AMV audio decoder
[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
0147f198
FR
53/* step_table[] and index_table[] are from the ADPCM reference source */
54/* This is the index table: */
135ee03a 55static const int index_table[16] = {
0147f198
FR
56 -1, -1, -1, -1, 2, 4, 6, 8,
57 -1, -1, -1, -1, 2, 4, 6, 8,
58};
59
115329f1 60/**
983e3246 61 * This is the step table. Note that many programs use slight deviations from
0147f198
FR
62 * this table, but such deviations are negligible:
63 */
135ee03a 64static const int step_table[89] = {
0147f198
FR
65 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
66 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
67 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
68 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
69 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
70 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
71 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
72 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
73 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
74};
75
fc384777 76/* These are for MS-ADPCM */
0147f198 77/* AdaptationTable[], AdaptCoeff1[], and AdaptCoeff2[] are from libsndfile */
135ee03a 78static const int AdaptationTable[] = {
0147f198
FR
79 230, 230, 230, 230, 307, 409, 512, 614,
80 768, 614, 512, 409, 307, 230, 230, 230
81};
82
135ee03a 83static const int AdaptCoeff1[] = {
0147f198
FR
84 256, 512, 0, 192, 240, 460, 392
85};
86
135ee03a 87static const int AdaptCoeff2[] = {
0147f198
FR
88 0, -256, 0, 64, 0, -208, -232
89};
90
fc384777 91/* These are for CD-ROM XA ADPCM */
1ffb0091 92static const int xa_adpcm_table[5][2] = {
fc384777
MM
93 { 0, 0 },
94 { 60, 0 },
95 { 115, -52 },
96 { 98, -55 },
97 { 122, -60 }
98};
99
c26ae41d 100static const int ea_adpcm_table[] = {
7d8379f2
MM
101 0, 240, 460, 392, 0, 0, -208, -220, 0, 1,
102 3, 4, 7, 8, 10, 11, 0, -1, -3, -4
103};
104
c26ae41d 105static const int ct_adpcm_table[8] = {
b3bfb299
MM
106 0x00E6, 0x00E6, 0x00E6, 0x00E6,
107 0x0133, 0x0199, 0x0200, 0x0266
108};
109
659c3692 110// padded to zero where table size is less then 16
c26ae41d 111static const int swf_index_tables[4][16] = {
659c3692
AB
112 /*2*/ { -1, 2 },
113 /*3*/ { -1, -1, 2, 4 },
114 /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },
115 /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
116};
117
2ff4524e
VM
118static const int yamaha_indexscale[] = {
119 230, 230, 230, 230, 307, 409, 512, 614,
120 230, 230, 230, 230, 307, 409, 512, 614
121};
122
123static const int yamaha_difflookup[] = {
124 1, 3, 5, 7, 9, 11, 13, 15,
125 -1, -3, -5, -7, -9, -11, -13, -15
126};
127
0147f198
FR
128/* end of tables */
129
130typedef struct ADPCMChannelStatus {
131 int predictor;
132 short int step_index;
133 int step;
889c5224
FR
134 /* for encoding */
135 int prev_sample;
0147f198
FR
136
137 /* MS version */
138 short sample1;
139 short sample2;
140 int coeff1;
141 int coeff2;
142 int idelta;
143} ADPCMChannelStatus;
144
145typedef struct ADPCMContext {
146 int channel; /* for stereo MOVs, decode left, then decode right, then tell it's decoded */
147 ADPCMChannelStatus status[2];
148 short sample_buffer[32]; /* hold left samples while waiting for right samples */
149} ADPCMContext;
150
151/* XXX: implement encoding */
152
764ef400 153#ifdef CONFIG_ENCODERS
0147f198
FR
154static int adpcm_encode_init(AVCodecContext *avctx)
155{
889c5224
FR
156 if (avctx->channels > 2)
157 return -1; /* only stereo or mono =) */
0147f198
FR
158 switch(avctx->codec->id) {
159 case CODEC_ID_ADPCM_IMA_QT:
8dbcc9f2 160 av_log(avctx, AV_LOG_ERROR, "ADPCM: codec adpcm_ima_qt unsupported for encoding !\n");
889c5224
FR
161 avctx->frame_size = 64; /* XXX: can multiple of avctx->channels * 64 (left and right blocks are interleaved) */
162 return -1;
0147f198
FR
163 break;
164 case CODEC_ID_ADPCM_IMA_WAV:
889c5224
FR
165 avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */
166 /* and we have 4 bytes per channel overhead */
167 avctx->block_align = BLKSIZE;
168 /* seems frame_size isn't taken into account... have to buffer the samples :-( */
169 break;
170 case CODEC_ID_ADPCM_MS:
6cf9d5eb
MN
171 avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */
172 /* and we have 7 bytes per channel overhead */
173 avctx->block_align = BLKSIZE;
0147f198 174 break;
2ff4524e
VM
175 case CODEC_ID_ADPCM_YAMAHA:
176 avctx->frame_size = BLKSIZE * avctx->channels;
177 avctx->block_align = BLKSIZE;
178 break;
d64b88d4 179 case CODEC_ID_ADPCM_SWF:
9fff16bc
BC
180 if (avctx->sample_rate != 11025 &&
181 avctx->sample_rate != 22050 &&
182 avctx->sample_rate != 44100) {
183 av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, 22050 or 44100\n");
184 return -1;
185 }
186 avctx->frame_size = 512 * (avctx->sample_rate / 11025);
d64b88d4 187 break;
0147f198 188 default:
889c5224 189 return -1;
0147f198
FR
190 break;
191 }
492cd3a9
MN
192
193 avctx->coded_frame= avcodec_alloc_frame();
194 avctx->coded_frame->key_frame= 1;
195
0147f198
FR
196 return 0;
197}
198
199static int adpcm_encode_close(AVCodecContext *avctx)
200{
492cd3a9
MN
201 av_freep(&avctx->coded_frame);
202
0147f198
FR
203 return 0;
204}
205
889c5224
FR
206
207static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample)
208{
7e537051
LM
209 int delta = sample - c->prev_sample;
210 int nibble = FFMIN(7, abs(delta)*4/step_table[c->step_index]) + (delta<0)*8;
295f3737 211 c->prev_sample += ((step_table[c->step_index] * yamaha_difflookup[nibble]) / 8);
aee481ce 212 c->prev_sample = av_clip_int16(c->prev_sample);
f66e4f5f 213 c->step_index = av_clip(c->step_index + index_table[nibble], 0, 88);
889c5224
FR
214 return nibble;
215}
216
6cf9d5eb
MN
217static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample)
218{
219 int predictor, nibble, bias;
220
221 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
115329f1 222
6cf9d5eb
MN
223 nibble= sample - predictor;
224 if(nibble>=0) bias= c->idelta/2;
225 else bias=-c->idelta/2;
115329f1 226
6cf9d5eb 227 nibble= (nibble + bias) / c->idelta;
f66e4f5f 228 nibble= av_clip(nibble, -8, 7)&0x0F;
115329f1 229
6cf9d5eb 230 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
6cf9d5eb
MN
231
232 c->sample2 = c->sample1;
295f3737 233 c->sample1 = av_clip_int16(predictor);
6cf9d5eb
MN
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
295f3737 254 c->predictor += ((c->step * yamaha_difflookup[nibble]) / 8);
aee481ce 255 c->predictor = av_clip_int16(c->predictor);
7e537051 256 c->step = (c->step * yamaha_indexscale[nibble]) >> 8;
f66e4f5f 257 c->step = av_clip(c->step, 127, 24567);
2ff4524e 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;
1cbe9d6a 300 if((version == CODEC_ID_ADPCM_IMA_WAV) || (version == CODEC_ID_ADPCM_SWF))
696d6889
LM
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;
f66e4f5f
RD
327 const int nmin = av_clip(div-range, -8, 6);
328 const int nmax = av_clip(div+range, -7, 7);
696d6889
LM
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;\
aee481ce 335 dec_sample = av_clip_int16(dec_sample);\
696d6889
LM
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 }
1cbe9d6a 371 } else if((version == CODEC_ID_ADPCM_IMA_WAV)|| (version == CODEC_ID_ADPCM_SWF)) {
696d6889
LM
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;\
f66e4f5f
RD
375 int nmin = av_clip(div-range, -7, 6);\
376 int nmax = av_clip(div+range, -6, 7);\
696d6889
LM
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 }
f66e4f5f 384 LOOP_NODES(ima, step_table[step], av_clip(step + index_table[nibble], 0, 88));
696d6889 385 } else { //CODEC_ID_ADPCM_YAMAHA
f66e4f5f 386 LOOP_NODES(yamaha, step, av_clip((step * yamaha_indexscale[nibble]) >> 8, 127, 24567));
696d6889
LM
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 */
2c124cb6 453 bytestream_put_le16(&dst, c->status[0].prev_sample);
889c5224
FR
454 *dst++ = (unsigned char)c->status[0].step_index;
455 *dst++ = 0; /* unknown */
456 samples++;
457 if (avctx->channels == 2) {
1ffb0091 458 c->status[1].prev_sample = (signed short)samples[1];
889c5224 459/* c->status[1].step_index = 0; */
2c124cb6 460 bytestream_put_le16(&dst, c->status[1].prev_sample);
889c5224
FR
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;
d64b88d4
BL
516 case CODEC_ID_ADPCM_SWF:
517 {
518 int i;
519 PutBitContext pb;
520 init_put_bits(&pb, dst, buf_size*8);
521
1cbe9d6a
BL
522 n = avctx->frame_size-1;
523
d64b88d4
BL
524 //Store AdpcmCodeSize
525 put_bits(&pb, 2, 2); //Set 4bits flash adpcm format
526
527 //Init the encoder state
528 for(i=0; i<avctx->channels; i++){
ac069107 529 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63); // clip step so it fits 6 bits
d64b88d4 530 put_bits(&pb, 16, samples[i] & 0xFFFF);
ac069107 531 put_bits(&pb, 6, c->status[i].step_index);
d64b88d4
BL
532 c->status[i].prev_sample = (signed short)samples[i];
533 }
534
1cbe9d6a
BL
535 if(avctx->trellis > 0) {
536 uint8_t buf[2][n];
537 adpcm_compress_trellis(avctx, samples+2, buf[0], &c->status[0], n);
538 if (avctx->channels == 2)
539 adpcm_compress_trellis(avctx, samples+3, buf[1], &c->status[1], n);
540 for(i=0; i<n; i++) {
541 put_bits(&pb, 4, buf[0][i]);
542 if (avctx->channels == 2)
543 put_bits(&pb, 4, buf[1][i]);
544 }
545 } else {
622d6332
BL
546 for (i=1; i<avctx->frame_size; i++) {
547 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i]) & 0xF);
548 if (avctx->channels == 2)
549 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1]) & 0xF);
1cbe9d6a 550 }
d64b88d4 551 }
9fff16bc
BC
552 flush_put_bits(&pb);
553 dst += put_bits_count(&pb)>>3;
d64b88d4
BL
554 break;
555 }
6cf9d5eb
MN
556 case CODEC_ID_ADPCM_MS:
557 for(i=0; i<avctx->channels; i++){
558 int predictor=0;
559
560 *dst++ = predictor;
561 c->status[i].coeff1 = AdaptCoeff1[predictor];
562 c->status[i].coeff2 = AdaptCoeff2[predictor];
563 }
564 for(i=0; i<avctx->channels; i++){
115329f1 565 if (c->status[i].idelta < 16)
6cf9d5eb 566 c->status[i].idelta = 16;
115329f1 567
2c124cb6 568 bytestream_put_le16(&dst, c->status[i].idelta);
6cf9d5eb
MN
569 }
570 for(i=0; i<avctx->channels; i++){
571 c->status[i].sample1= *samples++;
572
2c124cb6 573 bytestream_put_le16(&dst, c->status[i].sample1);
6cf9d5eb
MN
574 }
575 for(i=0; i<avctx->channels; i++){
576 c->status[i].sample2= *samples++;
577
2c124cb6 578 bytestream_put_le16(&dst, c->status[i].sample2);
6cf9d5eb
MN
579 }
580
696d6889
LM
581 if(avctx->trellis > 0) {
582 int n = avctx->block_align - 7*avctx->channels;
583 uint8_t buf[2][n];
584 if(avctx->channels == 1) {
585 n *= 2;
586 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
587 for(i=0; i<n; i+=2)
588 *dst++ = (buf[0][i] << 4) | buf[0][i+1];
589 } else {
590 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
591 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
592 for(i=0; i<n; i++)
593 *dst++ = (buf[0][i] << 4) | buf[1][i];
594 }
595 } else
6cf9d5eb
MN
596 for(i=7*avctx->channels; i<avctx->block_align; i++) {
597 int nibble;
598 nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4;
599 nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++);
600 *dst++ = nibble;
601 }
602 break;
2ff4524e
VM
603 case CODEC_ID_ADPCM_YAMAHA:
604 n = avctx->frame_size / 2;
696d6889
LM
605 if(avctx->trellis > 0) {
606 uint8_t buf[2][n*2];
607 n *= 2;
608 if(avctx->channels == 1) {
609 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
610 for(i=0; i<n; i+=2)
611 *dst++ = buf[0][i] | (buf[0][i+1] << 4);
612 } else {
613 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
614 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
615 for(i=0; i<n; i++)
616 *dst++ = buf[0][i] | (buf[1][i] << 4);
617 }
618 } else
2ff4524e
VM
619 for (; n>0; n--) {
620 for(i = 0; i < avctx->channels; i++) {
621 int nibble;
b194c327
MN
622 nibble = adpcm_yamaha_compress_sample(&c->status[i], samples[i]);
623 nibble |= adpcm_yamaha_compress_sample(&c->status[i], samples[i+avctx->channels]) << 4;
2ff4524e
VM
624 *dst++ = nibble;
625 }
626 samples += 2 * avctx->channels;
627 }
628 break;
0147f198
FR
629 default:
630 return -1;
631 }
0147f198
FR
632 return dst - frame;
633}
764ef400 634#endif //CONFIG_ENCODERS
0147f198
FR
635
636static int adpcm_decode_init(AVCodecContext * avctx)
637{
638 ADPCMContext *c = avctx->priv_data;
639
14c49573
MN
640 if(avctx->channels > 2U){
641 return -1;
642 }
643
0147f198
FR
644 c->channel = 0;
645 c->status[0].predictor = c->status[1].predictor = 0;
646 c->status[0].step_index = c->status[1].step_index = 0;
647 c->status[0].step = c->status[1].step = 0;
648
649 switch(avctx->codec->id) {
b3bfb299 650 case CODEC_ID_ADPCM_CT:
bb270c08
DB
651 c->status[0].step = c->status[1].step = 511;
652 break;
8e952e4d
AH
653 case CODEC_ID_ADPCM_IMA_WS:
654 if (avctx->extradata && avctx->extradata_size == 2 * 4) {
655 c->status[0].predictor = AV_RL32(avctx->extradata);
656 c->status[1].predictor = AV_RL32(avctx->extradata + 4);
657 }
658 break;
0147f198
FR
659 default:
660 break;
661 }
662 return 0;
663}
664
d94728c3 665static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
0147f198
FR
666{
667 int step_index;
668 int predictor;
669 int sign, delta, diff, step;
670
135ee03a 671 step = step_table[c->step_index];
0147f198
FR
672 step_index = c->step_index + index_table[(unsigned)nibble];
673 if (step_index < 0) step_index = 0;
135ee03a 674 else if (step_index > 88) step_index = 88;
0147f198 675
0147f198
FR
676 sign = nibble & 8;
677 delta = nibble & 7;
9937e686
MM
678 /* perform direct multiplication instead of series of jumps proposed by
679 * the reference ADPCM implementation since modern CPUs can do the mults
680 * quickly enough */
d94728c3 681 diff = ((2 * delta + 1) * step) >> shift;
4b465299
MN
682 predictor = c->predictor;
683 if (sign) predictor -= diff;
684 else predictor += diff;
685
295f3737 686 c->predictor = av_clip_int16(predictor);
4b465299
MN
687 c->step_index = step_index;
688
295f3737 689 return (short)c->predictor;
4b465299
MN
690}
691
0147f198
FR
692static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
693{
694 int predictor;
695
696 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
697 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
0147f198
FR
698
699 c->sample2 = c->sample1;
295f3737 700 c->sample1 = av_clip_int16(predictor);
6cf9d5eb 701 c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
0147f198
FR
702 if (c->idelta < 16) c->idelta = 16;
703
295f3737 704 return c->sample1;
0147f198
FR
705}
706
b3bfb299
MM
707static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
708{
b3bfb299
MM
709 int sign, delta, diff;
710 int new_step;
711
712 sign = nibble & 8;
713 delta = nibble & 7;
714 /* perform direct multiplication instead of series of jumps proposed by
715 * the reference ADPCM implementation since modern CPUs can do the mults
716 * quickly enough */
717 diff = ((2 * delta + 1) * c->step) >> 3;
b3bfb299 718 /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
e4a50e6d
AJ
719 c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
720 c->predictor = av_clip_int16(c->predictor);
b3bfb299
MM
721 /* calculate new step and clamp it to range 511..32767 */
722 new_step = (ct_adpcm_table[nibble & 7] * c->step) >> 8;
88e2d588 723 c->step = av_clip(new_step, 511, 32767);
b3bfb299 724
295f3737 725 return (short)c->predictor;
b3bfb299
MM
726}
727
2433f24f
AJ
728static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
729{
730 int sign, delta, diff;
731
732 sign = nibble & (1<<(size-1));
733 delta = nibble & ((1<<(size-1))-1);
734 diff = delta << (7 + c->step + shift);
735
2433f24f 736 /* clamp result */
88e2d588 737 c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
2433f24f
AJ
738
739 /* calculate new step */
740 if (delta >= (2*size - 3) && c->step < 3)
741 c->step++;
742 else if (delta == 0 && c->step > 0)
743 c->step--;
744
745 return (short) c->predictor;
746}
747
2ff4524e
VM
748static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
749{
750 if(!c->step) {
751 c->predictor = 0;
752 c->step = 127;
753 }
754
755 c->predictor += (c->step * yamaha_difflookup[nibble]) / 8;
aee481ce 756 c->predictor = av_clip_int16(c->predictor);
2ff4524e 757 c->step = (c->step * yamaha_indexscale[nibble]) >> 8;
f66e4f5f 758 c->step = av_clip(c->step, 127, 24567);
2ff4524e
VM
759 return c->predictor;
760}
761
115329f1 762static void xa_decode(short *out, const unsigned char *in,
fc384777
MM
763 ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
764{
765 int i, j;
766 int shift,filter,f0,f1;
767 int s_1,s_2;
768 int d,s,t;
769
770 for(i=0;i<4;i++) {
771
772 shift = 12 - (in[4+i*2] & 15);
773 filter = in[4+i*2] >> 4;
774 f0 = xa_adpcm_table[filter][0];
775 f1 = xa_adpcm_table[filter][1];
776
777 s_1 = left->sample1;
778 s_2 = left->sample2;
779
780 for(j=0;j<28;j++) {
781 d = in[16+i+j*4];
782
783 t = (signed char)(d<<4)>>4;
784 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
fc384777 785 s_2 = s_1;
295f3737
AJ
786 s_1 = av_clip_int16(s);
787 *out = s_1;
788 out += inc;
fc384777
MM
789 }
790
791 if (inc==2) { /* stereo */
792 left->sample1 = s_1;
793 left->sample2 = s_2;
794 s_1 = right->sample1;
795 s_2 = right->sample2;
796 out = out + 1 - 28*2;
797 }
798
799 shift = 12 - (in[5+i*2] & 15);
800 filter = in[5+i*2] >> 4;
801
802 f0 = xa_adpcm_table[filter][0];
803 f1 = xa_adpcm_table[filter][1];
804
805 for(j=0;j<28;j++) {
806 d = in[16+i+j*4];
807
808 t = (signed char)d >> 4;
809 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
fc384777 810 s_2 = s_1;
295f3737
AJ
811 s_1 = av_clip_int16(s);
812 *out = s_1;
813 out += inc;
fc384777
MM
814 }
815
816 if (inc==2) { /* stereo */
817 right->sample1 = s_1;
818 right->sample2 = s_2;
819 out -= 1;
820 } else {
821 left->sample1 = s_1;
822 left->sample2 = s_2;
823 }
824 }
825}
826
827
9937e686
MM
828/* DK3 ADPCM support macro */
829#define DK3_GET_NEXT_NIBBLE() \
830 if (decode_top_nibble_next) \
831 { \
832 nibble = (last_byte >> 4) & 0x0F; \
833 decode_top_nibble_next = 0; \
834 } \
835 else \
836 { \
837 last_byte = *src++; \
838 if (src >= buf + buf_size) break; \
839 nibble = last_byte & 0x0F; \
840 decode_top_nibble_next = 1; \
841 }
842
0147f198 843static int adpcm_decode_frame(AVCodecContext *avctx,
bb270c08
DB
844 void *data, int *data_size,
845 uint8_t *buf, int buf_size)
0147f198
FR
846{
847 ADPCMContext *c = avctx->priv_data;
848 ADPCMChannelStatus *cs;
4b465299 849 int n, m, channel, i;
0147f198
FR
850 int block_predictor[2];
851 short *samples;
14c49573 852 short *samples_end;
0c1a9eda 853 uint8_t *src;
0147f198
FR
854 int st; /* stereo */
855
9937e686
MM
856 /* DK3 ADPCM accounting variables */
857 unsigned char last_byte = 0;
858 unsigned char nibble;
859 int decode_top_nibble_next = 0;
860 int diff_channel;
861
7d8379f2
MM
862 /* EA ADPCM state variables */
863 uint32_t samples_in_chunk;
864 int32_t previous_left_sample, previous_right_sample;
865 int32_t current_left_sample, current_right_sample;
866 int32_t next_left_sample, next_right_sample;
867 int32_t coeff1l, coeff2l, coeff1r, coeff2r;
868 uint8_t shift_left, shift_right;
869 int count1, count2;
870
df72754d
MM
871 if (!buf_size)
872 return 0;
873
14c49573
MN
874 //should protect all 4bit ADPCM variants
875 //8 is needed for CODEC_ID_ADPCM_IMA_WAV with 2 channels
876 //
877 if(*data_size/4 < buf_size + 8)
878 return -1;
879
0147f198 880 samples = data;
14c49573
MN
881 samples_end= samples + *data_size/2;
882 *data_size= 0;
0147f198
FR
883 src = buf;
884
2433f24f 885 st = avctx->channels == 2 ? 1 : 0;
0147f198
FR
886
887 switch(avctx->codec->id) {
888 case CODEC_ID_ADPCM_IMA_QT:
889 n = (buf_size - 2);/* >> 2*avctx->channels;*/
890 channel = c->channel;
891 cs = &(c->status[channel]);
892 /* (pppppp) (piiiiiii) */
893
894 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
895 cs->predictor = (*src++) << 8;
896 cs->predictor |= (*src & 0x80);
897 cs->predictor &= 0xFF80;
898
899 /* sign extension */
900 if(cs->predictor & 0x8000)
901 cs->predictor -= 0x10000;
902
aee481ce 903 cs->predictor = av_clip_int16(cs->predictor);
0147f198
FR
904
905 cs->step_index = (*src++) & 0x7F;
906
8d359bba
MN
907 if (cs->step_index > 88){
908 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
909 cs->step_index = 88;
910 }
0147f198
FR
911
912 cs->step = step_table[cs->step_index];
913
914 if (st && channel)
915 samples++;
916
917 for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
d94728c3 918 *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3);
0147f198 919 samples += avctx->channels;
d94728c3 920 *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F, 3);
0147f198
FR
921 samples += avctx->channels;
922 src ++;
923 }
924
925 if(st) { /* handle stereo interlacing */
926 c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
ac3d5cac 927 if(channel == 1) { /* wait for the other packet before outputing anything */
0147f198
FR
928 return src - buf;
929 }
930 }
931 break;
932 case CODEC_ID_ADPCM_IMA_WAV:
ca1d62f4
AY
933 if (avctx->block_align != 0 && buf_size > avctx->block_align)
934 buf_size = avctx->block_align;
935
8d359bba
MN
936// samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1;
937
d94728c3
MN
938 for(i=0; i<avctx->channels; i++){
939 cs = &(c->status[i]);
8d359bba
MN
940 cs->predictor = (int16_t)(src[0] + (src[1]<<8));
941 src+=2;
0147f198 942
bb270c08 943 // XXX: is this correct ??: *samples++ = cs->predictor;
889c5224 944
d94728c3 945 cs->step_index = *src++;
8d359bba
MN
946 if (cs->step_index > 88){
947 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
948 cs->step_index = 88;
949 }
950 if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */
0147f198 951 }
0147f198 952
8d359bba
MN
953 while(src < buf + buf_size){
954 for(m=0; m<4; m++){
955 for(i=0; i<=st; i++)
956 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3);
957 for(i=0; i<=st; i++)
958 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4 , 3);
959 src++;
bb270c08 960 }
8d359bba 961 src += 4*st;
bb270c08 962 }
0147f198 963 break;
4b465299
MN
964 case CODEC_ID_ADPCM_4XM:
965 cs = &(c->status[0]);
966 c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
967 if(st){
968 c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
969 }
970 c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
971 if(st){
972 c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
973 }
ac3d5cac
MM
974 if (cs->step_index < 0) cs->step_index = 0;
975 if (cs->step_index > 88) cs->step_index = 88;
4b465299
MN
976
977 m= (buf_size - (src - buf))>>st;
4b465299 978 for(i=0; i<m; i++) {
bb270c08 979 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);
4b465299 980 if (st)
d94728c3
MN
981 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);
982 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);
bb270c08 983 if (st)
d94728c3 984 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);
bb270c08 985 }
4b465299
MN
986
987 src += m<<st;
988
989 break;
0147f198 990 case CODEC_ID_ADPCM_MS:
ca1d62f4
AY
991 if (avctx->block_align != 0 && buf_size > avctx->block_align)
992 buf_size = avctx->block_align;
0147f198
FR
993 n = buf_size - 7 * avctx->channels;
994 if (n < 0)
995 return -1;
f66e4f5f 996 block_predictor[0] = av_clip(*src++, 0, 7);
0147f198
FR
997 block_predictor[1] = 0;
998 if (st)
f66e4f5f 999 block_predictor[1] = av_clip(*src++, 0, 7);
6cf9d5eb 1000 c->status[0].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
0147f198 1001 src+=2;
6cf9d5eb
MN
1002 if (st){
1003 c->status[1].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
0147f198 1004 src+=2;
6cf9d5eb 1005 }
0147f198
FR
1006 c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
1007 c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
1008 c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
1009 c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
115329f1 1010
0147f198
FR
1011 c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1012 src+=2;
1013 if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1014 if (st) src+=2;
1015 c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1016 src+=2;
1017 if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1018 if (st) src+=2;
1019
1020 *samples++ = c->status[0].sample1;
1021 if (st) *samples++ = c->status[1].sample1;
1022 *samples++ = c->status[0].sample2;
1023 if (st) *samples++ = c->status[1].sample2;
1024 for(;n>0;n--) {
1025 *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
1026 *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
1027 src ++;
1028 }
1029 break;
9937e686 1030 case CODEC_ID_ADPCM_IMA_DK4:
5c69a4fd
MN
1031 if (avctx->block_align != 0 && buf_size > avctx->block_align)
1032 buf_size = avctx->block_align;
1033
6cf9d5eb 1034 c->status[0].predictor = (int16_t)(src[0] | (src[1] << 8));
9937e686
MM
1035 c->status[0].step_index = src[2];
1036 src += 4;
9937e686
MM
1037 *samples++ = c->status[0].predictor;
1038 if (st) {
6cf9d5eb 1039 c->status[1].predictor = (int16_t)(src[0] | (src[1] << 8));
9937e686
MM
1040 c->status[1].step_index = src[2];
1041 src += 4;
9937e686
MM
1042 *samples++ = c->status[1].predictor;
1043 }
1044 while (src < buf + buf_size) {
1045
1046 /* take care of the top nibble (always left or mono channel) */
115329f1 1047 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1048 (src[0] >> 4) & 0x0F, 3);
9937e686
MM
1049
1050 /* take care of the bottom nibble, which is right sample for
1051 * stereo, or another mono sample */
1052 if (st)
115329f1 1053 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
d94728c3 1054 src[0] & 0x0F, 3);
9937e686 1055 else
115329f1 1056 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1057 src[0] & 0x0F, 3);
9937e686
MM
1058
1059 src++;
1060 }
1061 break;
1062 case CODEC_ID_ADPCM_IMA_DK3:
5c69a4fd
MN
1063 if (avctx->block_align != 0 && buf_size > avctx->block_align)
1064 buf_size = avctx->block_align;
1065
14c49573
MN
1066 if(buf_size + 16 > (samples_end - samples)*3/8)
1067 return -1;
1068
6cf9d5eb
MN
1069 c->status[0].predictor = (int16_t)(src[10] | (src[11] << 8));
1070 c->status[1].predictor = (int16_t)(src[12] | (src[13] << 8));
9937e686
MM
1071 c->status[0].step_index = src[14];
1072 c->status[1].step_index = src[15];
1073 /* sign extend the predictors */
9937e686
MM
1074 src += 16;
1075 diff_channel = c->status[1].predictor;
1076
1077 /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
1078 * the buffer is consumed */
1079 while (1) {
1080
1081 /* for this algorithm, c->status[0] is the sum channel and
1082 * c->status[1] is the diff channel */
1083
1084 /* process the first predictor of the sum channel */
1085 DK3_GET_NEXT_NIBBLE();
d94728c3 1086 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
9937e686
MM
1087
1088 /* process the diff channel predictor */
1089 DK3_GET_NEXT_NIBBLE();
d94728c3 1090 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
9937e686
MM
1091
1092 /* process the first pair of stereo PCM samples */
1093 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1094 *samples++ = c->status[0].predictor + c->status[1].predictor;
1095 *samples++ = c->status[0].predictor - c->status[1].predictor;
1096
1097 /* process the second predictor of the sum channel */
1098 DK3_GET_NEXT_NIBBLE();
d94728c3 1099 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
9937e686
MM
1100
1101 /* process the second pair of stereo PCM samples */
1102 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1103 *samples++ = c->status[0].predictor + c->status[1].predictor;
1104 *samples++ = c->status[0].predictor - c->status[1].predictor;
1105 }
1106 break;
2fdf638b
MM
1107 case CODEC_ID_ADPCM_IMA_WS:
1108 /* no per-block initialization; just start decoding the data */
1109 while (src < buf + buf_size) {
1110
1111 if (st) {
115329f1 1112 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1113 (src[0] >> 4) & 0x0F, 3);
115329f1 1114 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
d94728c3 1115 src[0] & 0x0F, 3);
2fdf638b 1116 } else {
115329f1 1117 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1118 (src[0] >> 4) & 0x0F, 3);
115329f1 1119 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1120 src[0] & 0x0F, 3);
2fdf638b
MM
1121 }
1122
1123 src++;
1124 }
1125 break;
fc384777 1126 case CODEC_ID_ADPCM_XA:
115329f1 1127 c->status[0].sample1 = c->status[0].sample2 =
fc384777
MM
1128 c->status[1].sample1 = c->status[1].sample2 = 0;
1129 while (buf_size >= 128) {
115329f1 1130 xa_decode(samples, src, &c->status[0], &c->status[1],
fc384777
MM
1131 avctx->channels);
1132 src += 128;
1133 samples += 28 * 8;
1134 buf_size -= 128;
1135 }
1136 break;
7d8379f2 1137 case CODEC_ID_ADPCM_EA:
fead30d4 1138 samples_in_chunk = AV_RL32(src);
7d8379f2
MM
1139 if (samples_in_chunk >= ((buf_size - 12) * 2)) {
1140 src += buf_size;
1141 break;
1142 }
1143 src += 4;
fead30d4 1144 current_left_sample = (int16_t)AV_RL16(src);
7d8379f2 1145 src += 2;
fead30d4 1146 previous_left_sample = (int16_t)AV_RL16(src);
7d8379f2 1147 src += 2;
fead30d4 1148 current_right_sample = (int16_t)AV_RL16(src);
7d8379f2 1149 src += 2;
fead30d4 1150 previous_right_sample = (int16_t)AV_RL16(src);
7d8379f2
MM
1151 src += 2;
1152
1153 for (count1 = 0; count1 < samples_in_chunk/28;count1++) {
1154 coeff1l = ea_adpcm_table[(*src >> 4) & 0x0F];
1155 coeff2l = ea_adpcm_table[((*src >> 4) & 0x0F) + 4];
1156 coeff1r = ea_adpcm_table[*src & 0x0F];
1157 coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
1158 src++;
1159
1160 shift_left = ((*src >> 4) & 0x0F) + 8;
1161 shift_right = (*src & 0x0F) + 8;
1162 src++;
1163
1164 for (count2 = 0; count2 < 28; count2++) {
1165 next_left_sample = (((*src & 0xF0) << 24) >> shift_left);
1166 next_right_sample = (((*src & 0x0F) << 28) >> shift_right);
1167 src++;
1168
115329f1
DB
1169 next_left_sample = (next_left_sample +
1170 (current_left_sample * coeff1l) +
7d8379f2 1171 (previous_left_sample * coeff2l) + 0x80) >> 8;
115329f1
DB
1172 next_right_sample = (next_right_sample +
1173 (current_right_sample * coeff1r) +
7d8379f2 1174 (previous_right_sample * coeff2r) + 0x80) >> 8;
7d8379f2
MM
1175
1176 previous_left_sample = current_left_sample;
295f3737 1177 current_left_sample = av_clip_int16(next_left_sample);
7d8379f2 1178 previous_right_sample = current_right_sample;
295f3737 1179 current_right_sample = av_clip_int16(next_right_sample);
7d8379f2
MM
1180 *samples++ = (unsigned short)current_left_sample;
1181 *samples++ = (unsigned short)current_right_sample;
1182 }
1183 }
1184 break;
3a7f5d07 1185 case CODEC_ID_ADPCM_IMA_AMV:
7d8379f2
MM
1186 case CODEC_ID_ADPCM_IMA_SMJPEG:
1187 c->status[0].predictor = *src;
1188 src += 2;
1189 c->status[0].step_index = *src++;
1190 src++; /* skip another byte before getting to the meat */
3a7f5d07
VS
1191
1192 if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV)
1193 src+=4;
1194
7d8379f2 1195 while (src < buf + buf_size) {
3a7f5d07
VS
1196 char hi, lo;
1197 lo = *src & 0x0F;
1198 hi = (*src >> 4) & 0x0F;
1199
1200 if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV)
1201 FFSWAP(char, hi, lo);
1202
7d8379f2 1203 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
3a7f5d07 1204 lo, 3);
7d8379f2 1205 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
3a7f5d07 1206 hi, 3);
7d8379f2
MM
1207 src++;
1208 }
1209 break;
b3bfb299 1210 case CODEC_ID_ADPCM_CT:
bb270c08 1211 while (src < buf + buf_size) {
b3bfb299 1212 if (st) {
115329f1 1213 *samples++ = adpcm_ct_expand_nibble(&c->status[0],
b3bfb299 1214 (src[0] >> 4) & 0x0F);
115329f1 1215 *samples++ = adpcm_ct_expand_nibble(&c->status[1],
b3bfb299
MM
1216 src[0] & 0x0F);
1217 } else {
115329f1 1218 *samples++ = adpcm_ct_expand_nibble(&c->status[0],
b3bfb299 1219 (src[0] >> 4) & 0x0F);
115329f1 1220 *samples++ = adpcm_ct_expand_nibble(&c->status[0],
b3bfb299
MM
1221 src[0] & 0x0F);
1222 }
bb270c08 1223 src++;
b3bfb299
MM
1224 }
1225 break;
2433f24f
AJ
1226 case CODEC_ID_ADPCM_SBPRO_4:
1227 case CODEC_ID_ADPCM_SBPRO_3:
1228 case CODEC_ID_ADPCM_SBPRO_2:
1229 if (!c->status[0].step_index) {
1230 /* the first byte is a raw sample */
1231 *samples++ = 128 * (*src++ - 0x80);
1232 if (st)
1233 *samples++ = 128 * (*src++ - 0x80);
1234 c->status[0].step_index = 1;
1235 }
1236 if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) {
1237 while (src < buf + buf_size) {
1238 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1239 (src[0] >> 4) & 0x0F, 4, 0);
1240 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1241 src[0] & 0x0F, 4, 0);
1242 src++;
1243 }
1244 } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) {
14c49573 1245 while (src < buf + buf_size && samples + 2 < samples_end) {
2433f24f
AJ
1246 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1247 (src[0] >> 5) & 0x07, 3, 0);
1248 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1249 (src[0] >> 2) & 0x07, 3, 0);
1250 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1251 src[0] & 0x03, 2, 0);
1252 src++;
1253 }
1254 } else {
14c49573 1255 while (src < buf + buf_size && samples + 3 < samples_end) {
2433f24f
AJ
1256 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1257 (src[0] >> 6) & 0x03, 2, 2);
1258 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1259 (src[0] >> 4) & 0x03, 2, 2);
1260 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1261 (src[0] >> 2) & 0x03, 2, 2);
1262 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1263 src[0] & 0x03, 2, 2);
1264 src++;
1265 }
1266 }
1267 break;
659c3692
AB
1268 case CODEC_ID_ADPCM_SWF:
1269 {
bb270c08
DB
1270 GetBitContext gb;
1271 const int *table;
fe4ff07a 1272 int k0, signmask, nb_bits, count;
bb270c08
DB
1273 int size = buf_size*8;
1274
1275 init_get_bits(&gb, buf, size);
1276
90b5b51e 1277 //read bits & initial values
387afa9d
BC
1278 nb_bits = get_bits(&gb, 2)+2;
1279 //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits);
1280 table = swf_index_tables[nb_bits-2];
1281 k0 = 1 << (nb_bits-2);
1282 signmask = 1 << (nb_bits-1);
bb270c08 1283
fe4ff07a 1284 while (get_bits_count(&gb) <= size - 22*avctx->channels) {
387afa9d 1285 for (i = 0; i < avctx->channels; i++) {
d0fa156f
BC
1286 *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
1287 c->status[i].step_index = get_bits(&gb, 6);
1288 }
1289
1290 for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
1291 int i;
1292
1293 for (i = 0; i < avctx->channels; i++) {
1294 // similar to IMA adpcm
1295 int delta = get_bits(&gb, nb_bits);
1296 int step = step_table[c->status[i].step_index];
1297 long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
1298 int k = k0;
1299
1300 do {
1301 if (delta & k)
1302 vpdiff += step;
1303 step >>= 1;
1304 k >>= 1;
1305 } while(k);
1306 vpdiff += step;
1307
1308 if (delta & signmask)
1309 c->status[i].predictor -= vpdiff;
1310 else
1311 c->status[i].predictor += vpdiff;
1312
1313 c->status[i].step_index += table[delta & (~signmask)];
1314
1315 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
aee481ce 1316 c->status[i].predictor = av_clip_int16(c->status[i].predictor);
d0fa156f
BC
1317
1318 *samples++ = c->status[i].predictor;
1319 if (samples >= samples_end) {
1320 av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");
1321 return -1;
1322 }
387afa9d 1323 }
bb270c08
DB
1324 }
1325 }
387afa9d 1326 src += buf_size;
bb270c08 1327 break;
659c3692 1328 }
2ff4524e
VM
1329 case CODEC_ID_ADPCM_YAMAHA:
1330 while (src < buf + buf_size) {
1331 if (st) {
1332 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
2ff4524e 1333 src[0] & 0x0F);
b194c327 1334 *samples++ = adpcm_yamaha_expand_nibble(&c->status[1],
2ff4524e 1335 (src[0] >> 4) & 0x0F);
b194c327 1336 } else {
2ff4524e
VM
1337 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
1338 src[0] & 0x0F);
b194c327
MN
1339 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
1340 (src[0] >> 4) & 0x0F);
2ff4524e
VM
1341 }
1342 src++;
1343 }
1344 break;
d1e0d21f 1345 case CODEC_ID_ADPCM_THP:
90f2a1a0 1346 {
20f75707 1347 int table[2][16];
d1e0d21f 1348 unsigned int samplecnt;
b736a365 1349 int prev[2][2];
d1e0d21f
MG
1350 int ch;
1351
1352 if (buf_size < 80) {
1353 av_log(avctx, AV_LOG_ERROR, "frame too small\n");
1354 return -1;
1355 }
1356
949ed6bb
MN
1357 src+=4;
1358 samplecnt = bytestream_get_be32(&src);
d1e0d21f 1359
11d66266 1360 for (i = 0; i < 32; i++)
949ed6bb 1361 table[0][i] = (int16_t)bytestream_get_be16(&src);
d1e0d21f
MG
1362
1363 /* Initialize the previous sample. */
204424a4 1364 for (i = 0; i < 4; i++)
949ed6bb 1365 prev[0][i] = (int16_t)bytestream_get_be16(&src);
d1e0d21f
MG
1366
1367 if (samplecnt >= (samples_end - samples) / (st + 1)) {
1368 av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");
1369 return -1;
1370 }
1371
1372 for (ch = 0; ch <= st; ch++) {
1373 samples = (unsigned short *) data + ch;
1374
1375 /* Read in every sample for this channel. */
1376 for (i = 0; i < samplecnt / 14; i++) {
949ed6bb
MN
1377 int index = (*src >> 4) & 7;
1378 unsigned int exp = 28 - (*src++ & 15);
20f75707
MN
1379 int factor1 = table[ch][index * 2];
1380 int factor2 = table[ch][index * 2 + 1];
d1e0d21f
MG
1381
1382 /* Decode 14 samples. */
1383 for (n = 0; n < 14; n++) {
949ed6bb
MN
1384 int32_t sampledat;
1385 if(n&1) sampledat= *src++ <<28;
1386 else sampledat= (*src&0xF0)<<24;
d1e0d21f 1387
e457023a 1388 sampledat = ((prev[ch][0]*factor1
949ed6bb 1389 + prev[ch][1]*factor2) >> 11) + (sampledat>>exp);
295f3737 1390 *samples = av_clip_int16(sampledat);
b736a365
MN
1391 prev[ch][1] = prev[ch][0];
1392 prev[ch][0] = *samples++;
d1e0d21f
MG
1393
1394 /* In case of stereo, skip one sample, this sample
1395 is for the other channel. */
1396 samples += st;
1397 }
1398 }
1399 }
1400
1401 /* In the previous loop, in case stereo is used, samples is
1402 increased exactly one time too often. */
1403 samples -= st;
1404 break;
90f2a1a0 1405 }
d1e0d21f 1406
0147f198 1407 default:
0147f198
FR
1408 return -1;
1409 }
0c1a9eda 1410 *data_size = (uint8_t *)samples - (uint8_t *)data;
0147f198
FR
1411 return src - buf;
1412}
1413
764ef400
MM
1414
1415
1416#ifdef CONFIG_ENCODERS
1417#define ADPCM_ENCODER(id,name) \
0147f198
FR
1418AVCodec name ## _encoder = { \
1419 #name, \
1420 CODEC_TYPE_AUDIO, \
1421 id, \
1422 sizeof(ADPCMContext), \
1423 adpcm_encode_init, \
1424 adpcm_encode_frame, \
1425 adpcm_encode_close, \
1426 NULL, \
764ef400
MM
1427};
1428#else
1429#define ADPCM_ENCODER(id,name)
1430#endif
1431
1432#ifdef CONFIG_DECODERS
1433#define ADPCM_DECODER(id,name) \
0147f198
FR
1434AVCodec name ## _decoder = { \
1435 #name, \
1436 CODEC_TYPE_AUDIO, \
1437 id, \
1438 sizeof(ADPCMContext), \
1439 adpcm_decode_init, \
1440 NULL, \
1441 NULL, \
1442 adpcm_decode_frame, \
1443};
764ef400
MM
1444#else
1445#define ADPCM_DECODER(id,name)
1446#endif
1447
1448#define ADPCM_CODEC(id, name) \
1449ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)
0147f198 1450
1218a7e3
DB
1451ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm);
1452ADPCM_CODEC(CODEC_ID_ADPCM_CT, adpcm_ct);
1453ADPCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea);
3a7f5d07 1454ADPCM_CODEC(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv);
9937e686
MM
1455ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);
1456ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);
1218a7e3 1457ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
7d8379f2 1458ADPCM_CODEC(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
1218a7e3
DB
1459ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
1460ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);
0147f198 1461ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
2433f24f
AJ
1462ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4);
1463ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3);
1464ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2);
1218a7e3 1465ADPCM_CODEC(CODEC_ID_ADPCM_SWF, adpcm_swf);
d1e0d21f 1466ADPCM_CODEC(CODEC_ID_ADPCM_THP, adpcm_thp);
1218a7e3
DB
1467ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa);
1468ADPCM_CODEC(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha);
0147f198
FR
1469
1470#undef ADPCM_CODEC