Use defines instead of raw hex numbers to specify CRC polynomials
[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;
300 if(version == CODEC_ID_ADPCM_IMA_WAV)
301 nodes[0]->sample1 = c->prev_sample;
302 if(version == CODEC_ID_ADPCM_MS)
303 nodes[0]->step = c->idelta;
304 if(version == CODEC_ID_ADPCM_YAMAHA) {
305 if(c->step == 0) {
306 nodes[0]->step = 127;
307 nodes[0]->sample1 = 0;
308 } else {
309 nodes[0]->step = c->step;
310 nodes[0]->sample1 = c->predictor;
311 }
312 }
313
314 for(i=0; i<n; i++) {
315 TrellisNode *t = node_buf[i&1];
316 TrellisNode **u;
317 int sample = samples[i*stride];
318 memset(nodes_next, 0, frontier*sizeof(TrellisNode*));
319 for(j=0; j<frontier && nodes[j]; j++) {
320 // higher j have higher ssd already, so they're unlikely to use a suboptimal next sample too
321 const int range = (j < frontier/2) ? 1 : 0;
322 const int step = nodes[j]->step;
323 int nidx;
324 if(version == CODEC_ID_ADPCM_MS) {
325 const int predictor = ((nodes[j]->sample1 * c->coeff1) + (nodes[j]->sample2 * c->coeff2)) / 256;
326 const int div = (sample - predictor) / step;
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 }
371 } else if(version == CODEC_ID_ADPCM_IMA_WAV) {
372#define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
373 const int predictor = nodes[j]->sample1;\
374 const int div = (sample - predictor) * 4 / STEP_TABLE;\
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
522 //Store AdpcmCodeSize
523 put_bits(&pb, 2, 2); //Set 4bits flash adpcm format
524
525 //Init the encoder state
526 for(i=0; i<avctx->channels; i++){
ac069107 527 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63); // clip step so it fits 6 bits
d64b88d4 528 put_bits(&pb, 16, samples[i] & 0xFFFF);
ac069107 529 put_bits(&pb, 6, c->status[i].step_index);
d64b88d4
BL
530 c->status[i].prev_sample = (signed short)samples[i];
531 }
532
00a254b7 533 for (i=1; i<avctx->frame_size; i++) {
d64b88d4
BL
534 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i]) & 0xF);
535 if (avctx->channels == 2)
536 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1]) & 0xF);
537 }
9fff16bc
BC
538 flush_put_bits(&pb);
539 dst += put_bits_count(&pb)>>3;
d64b88d4
BL
540 break;
541 }
6cf9d5eb
MN
542 case CODEC_ID_ADPCM_MS:
543 for(i=0; i<avctx->channels; i++){
544 int predictor=0;
545
546 *dst++ = predictor;
547 c->status[i].coeff1 = AdaptCoeff1[predictor];
548 c->status[i].coeff2 = AdaptCoeff2[predictor];
549 }
550 for(i=0; i<avctx->channels; i++){
115329f1 551 if (c->status[i].idelta < 16)
6cf9d5eb 552 c->status[i].idelta = 16;
115329f1 553
2c124cb6 554 bytestream_put_le16(&dst, c->status[i].idelta);
6cf9d5eb
MN
555 }
556 for(i=0; i<avctx->channels; i++){
557 c->status[i].sample1= *samples++;
558
2c124cb6 559 bytestream_put_le16(&dst, c->status[i].sample1);
6cf9d5eb
MN
560 }
561 for(i=0; i<avctx->channels; i++){
562 c->status[i].sample2= *samples++;
563
2c124cb6 564 bytestream_put_le16(&dst, c->status[i].sample2);
6cf9d5eb
MN
565 }
566
696d6889
LM
567 if(avctx->trellis > 0) {
568 int n = avctx->block_align - 7*avctx->channels;
569 uint8_t buf[2][n];
570 if(avctx->channels == 1) {
571 n *= 2;
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] << 4) | buf[0][i+1];
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] << 4) | buf[1][i];
580 }
581 } else
6cf9d5eb
MN
582 for(i=7*avctx->channels; i<avctx->block_align; i++) {
583 int nibble;
584 nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4;
585 nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++);
586 *dst++ = nibble;
587 }
588 break;
2ff4524e
VM
589 case CODEC_ID_ADPCM_YAMAHA:
590 n = avctx->frame_size / 2;
696d6889
LM
591 if(avctx->trellis > 0) {
592 uint8_t buf[2][n*2];
593 n *= 2;
594 if(avctx->channels == 1) {
595 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
596 for(i=0; i<n; i+=2)
597 *dst++ = buf[0][i] | (buf[0][i+1] << 4);
598 } else {
599 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
600 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
601 for(i=0; i<n; i++)
602 *dst++ = buf[0][i] | (buf[1][i] << 4);
603 }
604 } else
2ff4524e
VM
605 for (; n>0; n--) {
606 for(i = 0; i < avctx->channels; i++) {
607 int nibble;
b194c327
MN
608 nibble = adpcm_yamaha_compress_sample(&c->status[i], samples[i]);
609 nibble |= adpcm_yamaha_compress_sample(&c->status[i], samples[i+avctx->channels]) << 4;
2ff4524e
VM
610 *dst++ = nibble;
611 }
612 samples += 2 * avctx->channels;
613 }
614 break;
0147f198
FR
615 default:
616 return -1;
617 }
0147f198
FR
618 return dst - frame;
619}
764ef400 620#endif //CONFIG_ENCODERS
0147f198
FR
621
622static int adpcm_decode_init(AVCodecContext * avctx)
623{
624 ADPCMContext *c = avctx->priv_data;
625
14c49573
MN
626 if(avctx->channels > 2U){
627 return -1;
628 }
629
0147f198
FR
630 c->channel = 0;
631 c->status[0].predictor = c->status[1].predictor = 0;
632 c->status[0].step_index = c->status[1].step_index = 0;
633 c->status[0].step = c->status[1].step = 0;
634
635 switch(avctx->codec->id) {
b3bfb299 636 case CODEC_ID_ADPCM_CT:
bb270c08
DB
637 c->status[0].step = c->status[1].step = 511;
638 break;
8e952e4d
AH
639 case CODEC_ID_ADPCM_IMA_WS:
640 if (avctx->extradata && avctx->extradata_size == 2 * 4) {
641 c->status[0].predictor = AV_RL32(avctx->extradata);
642 c->status[1].predictor = AV_RL32(avctx->extradata + 4);
643 }
644 break;
0147f198
FR
645 default:
646 break;
647 }
648 return 0;
649}
650
d94728c3 651static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
0147f198
FR
652{
653 int step_index;
654 int predictor;
655 int sign, delta, diff, step;
656
135ee03a 657 step = step_table[c->step_index];
0147f198
FR
658 step_index = c->step_index + index_table[(unsigned)nibble];
659 if (step_index < 0) step_index = 0;
135ee03a 660 else if (step_index > 88) step_index = 88;
0147f198 661
0147f198
FR
662 sign = nibble & 8;
663 delta = nibble & 7;
9937e686
MM
664 /* perform direct multiplication instead of series of jumps proposed by
665 * the reference ADPCM implementation since modern CPUs can do the mults
666 * quickly enough */
d94728c3 667 diff = ((2 * delta + 1) * step) >> shift;
4b465299
MN
668 predictor = c->predictor;
669 if (sign) predictor -= diff;
670 else predictor += diff;
671
295f3737 672 c->predictor = av_clip_int16(predictor);
4b465299
MN
673 c->step_index = step_index;
674
295f3737 675 return (short)c->predictor;
4b465299
MN
676}
677
0147f198
FR
678static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
679{
680 int predictor;
681
682 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
683 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
0147f198
FR
684
685 c->sample2 = c->sample1;
295f3737 686 c->sample1 = av_clip_int16(predictor);
6cf9d5eb 687 c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
0147f198
FR
688 if (c->idelta < 16) c->idelta = 16;
689
295f3737 690 return c->sample1;
0147f198
FR
691}
692
b3bfb299
MM
693static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
694{
b3bfb299
MM
695 int sign, delta, diff;
696 int new_step;
697
698 sign = nibble & 8;
699 delta = nibble & 7;
700 /* perform direct multiplication instead of series of jumps proposed by
701 * the reference ADPCM implementation since modern CPUs can do the mults
702 * quickly enough */
703 diff = ((2 * delta + 1) * c->step) >> 3;
b3bfb299 704 /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
e4a50e6d
AJ
705 c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
706 c->predictor = av_clip_int16(c->predictor);
b3bfb299
MM
707 /* calculate new step and clamp it to range 511..32767 */
708 new_step = (ct_adpcm_table[nibble & 7] * c->step) >> 8;
88e2d588 709 c->step = av_clip(new_step, 511, 32767);
b3bfb299 710
295f3737 711 return (short)c->predictor;
b3bfb299
MM
712}
713
2433f24f
AJ
714static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
715{
716 int sign, delta, diff;
717
718 sign = nibble & (1<<(size-1));
719 delta = nibble & ((1<<(size-1))-1);
720 diff = delta << (7 + c->step + shift);
721
2433f24f 722 /* clamp result */
88e2d588 723 c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
2433f24f
AJ
724
725 /* calculate new step */
726 if (delta >= (2*size - 3) && c->step < 3)
727 c->step++;
728 else if (delta == 0 && c->step > 0)
729 c->step--;
730
731 return (short) c->predictor;
732}
733
2ff4524e
VM
734static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
735{
736 if(!c->step) {
737 c->predictor = 0;
738 c->step = 127;
739 }
740
741 c->predictor += (c->step * yamaha_difflookup[nibble]) / 8;
aee481ce 742 c->predictor = av_clip_int16(c->predictor);
2ff4524e 743 c->step = (c->step * yamaha_indexscale[nibble]) >> 8;
f66e4f5f 744 c->step = av_clip(c->step, 127, 24567);
2ff4524e
VM
745 return c->predictor;
746}
747
115329f1 748static void xa_decode(short *out, const unsigned char *in,
fc384777
MM
749 ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
750{
751 int i, j;
752 int shift,filter,f0,f1;
753 int s_1,s_2;
754 int d,s,t;
755
756 for(i=0;i<4;i++) {
757
758 shift = 12 - (in[4+i*2] & 15);
759 filter = in[4+i*2] >> 4;
760 f0 = xa_adpcm_table[filter][0];
761 f1 = xa_adpcm_table[filter][1];
762
763 s_1 = left->sample1;
764 s_2 = left->sample2;
765
766 for(j=0;j<28;j++) {
767 d = in[16+i+j*4];
768
769 t = (signed char)(d<<4)>>4;
770 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
fc384777 771 s_2 = s_1;
295f3737
AJ
772 s_1 = av_clip_int16(s);
773 *out = s_1;
774 out += inc;
fc384777
MM
775 }
776
777 if (inc==2) { /* stereo */
778 left->sample1 = s_1;
779 left->sample2 = s_2;
780 s_1 = right->sample1;
781 s_2 = right->sample2;
782 out = out + 1 - 28*2;
783 }
784
785 shift = 12 - (in[5+i*2] & 15);
786 filter = in[5+i*2] >> 4;
787
788 f0 = xa_adpcm_table[filter][0];
789 f1 = xa_adpcm_table[filter][1];
790
791 for(j=0;j<28;j++) {
792 d = in[16+i+j*4];
793
794 t = (signed char)d >> 4;
795 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
fc384777 796 s_2 = s_1;
295f3737
AJ
797 s_1 = av_clip_int16(s);
798 *out = s_1;
799 out += inc;
fc384777
MM
800 }
801
802 if (inc==2) { /* stereo */
803 right->sample1 = s_1;
804 right->sample2 = s_2;
805 out -= 1;
806 } else {
807 left->sample1 = s_1;
808 left->sample2 = s_2;
809 }
810 }
811}
812
813
9937e686
MM
814/* DK3 ADPCM support macro */
815#define DK3_GET_NEXT_NIBBLE() \
816 if (decode_top_nibble_next) \
817 { \
818 nibble = (last_byte >> 4) & 0x0F; \
819 decode_top_nibble_next = 0; \
820 } \
821 else \
822 { \
823 last_byte = *src++; \
824 if (src >= buf + buf_size) break; \
825 nibble = last_byte & 0x0F; \
826 decode_top_nibble_next = 1; \
827 }
828
0147f198 829static int adpcm_decode_frame(AVCodecContext *avctx,
bb270c08
DB
830 void *data, int *data_size,
831 uint8_t *buf, int buf_size)
0147f198
FR
832{
833 ADPCMContext *c = avctx->priv_data;
834 ADPCMChannelStatus *cs;
4b465299 835 int n, m, channel, i;
0147f198
FR
836 int block_predictor[2];
837 short *samples;
14c49573 838 short *samples_end;
0c1a9eda 839 uint8_t *src;
0147f198
FR
840 int st; /* stereo */
841
9937e686
MM
842 /* DK3 ADPCM accounting variables */
843 unsigned char last_byte = 0;
844 unsigned char nibble;
845 int decode_top_nibble_next = 0;
846 int diff_channel;
847
7d8379f2
MM
848 /* EA ADPCM state variables */
849 uint32_t samples_in_chunk;
850 int32_t previous_left_sample, previous_right_sample;
851 int32_t current_left_sample, current_right_sample;
852 int32_t next_left_sample, next_right_sample;
853 int32_t coeff1l, coeff2l, coeff1r, coeff2r;
854 uint8_t shift_left, shift_right;
855 int count1, count2;
856
df72754d
MM
857 if (!buf_size)
858 return 0;
859
14c49573
MN
860 //should protect all 4bit ADPCM variants
861 //8 is needed for CODEC_ID_ADPCM_IMA_WAV with 2 channels
862 //
863 if(*data_size/4 < buf_size + 8)
864 return -1;
865
0147f198 866 samples = data;
14c49573
MN
867 samples_end= samples + *data_size/2;
868 *data_size= 0;
0147f198
FR
869 src = buf;
870
2433f24f 871 st = avctx->channels == 2 ? 1 : 0;
0147f198
FR
872
873 switch(avctx->codec->id) {
874 case CODEC_ID_ADPCM_IMA_QT:
875 n = (buf_size - 2);/* >> 2*avctx->channels;*/
876 channel = c->channel;
877 cs = &(c->status[channel]);
878 /* (pppppp) (piiiiiii) */
879
880 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
881 cs->predictor = (*src++) << 8;
882 cs->predictor |= (*src & 0x80);
883 cs->predictor &= 0xFF80;
884
885 /* sign extension */
886 if(cs->predictor & 0x8000)
887 cs->predictor -= 0x10000;
888
aee481ce 889 cs->predictor = av_clip_int16(cs->predictor);
0147f198
FR
890
891 cs->step_index = (*src++) & 0x7F;
892
8d359bba
MN
893 if (cs->step_index > 88){
894 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
895 cs->step_index = 88;
896 }
0147f198
FR
897
898 cs->step = step_table[cs->step_index];
899
900 if (st && channel)
901 samples++;
902
903 for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
d94728c3 904 *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3);
0147f198 905 samples += avctx->channels;
d94728c3 906 *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F, 3);
0147f198
FR
907 samples += avctx->channels;
908 src ++;
909 }
910
911 if(st) { /* handle stereo interlacing */
912 c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
ac3d5cac 913 if(channel == 1) { /* wait for the other packet before outputing anything */
0147f198
FR
914 return src - buf;
915 }
916 }
917 break;
918 case CODEC_ID_ADPCM_IMA_WAV:
ca1d62f4
AY
919 if (avctx->block_align != 0 && buf_size > avctx->block_align)
920 buf_size = avctx->block_align;
921
8d359bba
MN
922// samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1;
923
d94728c3
MN
924 for(i=0; i<avctx->channels; i++){
925 cs = &(c->status[i]);
8d359bba
MN
926 cs->predictor = (int16_t)(src[0] + (src[1]<<8));
927 src+=2;
0147f198 928
bb270c08 929 // XXX: is this correct ??: *samples++ = cs->predictor;
889c5224 930
d94728c3 931 cs->step_index = *src++;
8d359bba
MN
932 if (cs->step_index > 88){
933 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
934 cs->step_index = 88;
935 }
936 if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */
0147f198 937 }
0147f198 938
8d359bba
MN
939 while(src < buf + buf_size){
940 for(m=0; m<4; m++){
941 for(i=0; i<=st; i++)
942 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3);
943 for(i=0; i<=st; i++)
944 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4 , 3);
945 src++;
bb270c08 946 }
8d359bba 947 src += 4*st;
bb270c08 948 }
0147f198 949 break;
4b465299
MN
950 case CODEC_ID_ADPCM_4XM:
951 cs = &(c->status[0]);
952 c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
953 if(st){
954 c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
955 }
956 c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
957 if(st){
958 c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
959 }
ac3d5cac
MM
960 if (cs->step_index < 0) cs->step_index = 0;
961 if (cs->step_index > 88) cs->step_index = 88;
4b465299
MN
962
963 m= (buf_size - (src - buf))>>st;
4b465299 964 for(i=0; i<m; i++) {
bb270c08 965 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);
4b465299 966 if (st)
d94728c3
MN
967 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);
968 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);
bb270c08 969 if (st)
d94728c3 970 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);
bb270c08 971 }
4b465299
MN
972
973 src += m<<st;
974
975 break;
0147f198 976 case CODEC_ID_ADPCM_MS:
ca1d62f4
AY
977 if (avctx->block_align != 0 && buf_size > avctx->block_align)
978 buf_size = avctx->block_align;
0147f198
FR
979 n = buf_size - 7 * avctx->channels;
980 if (n < 0)
981 return -1;
f66e4f5f 982 block_predictor[0] = av_clip(*src++, 0, 7);
0147f198
FR
983 block_predictor[1] = 0;
984 if (st)
f66e4f5f 985 block_predictor[1] = av_clip(*src++, 0, 7);
6cf9d5eb 986 c->status[0].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
0147f198 987 src+=2;
6cf9d5eb
MN
988 if (st){
989 c->status[1].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
0147f198 990 src+=2;
6cf9d5eb 991 }
0147f198
FR
992 c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
993 c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
994 c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
995 c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
115329f1 996
0147f198
FR
997 c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
998 src+=2;
999 if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1000 if (st) src+=2;
1001 c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1002 src+=2;
1003 if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1004 if (st) src+=2;
1005
1006 *samples++ = c->status[0].sample1;
1007 if (st) *samples++ = c->status[1].sample1;
1008 *samples++ = c->status[0].sample2;
1009 if (st) *samples++ = c->status[1].sample2;
1010 for(;n>0;n--) {
1011 *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
1012 *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
1013 src ++;
1014 }
1015 break;
9937e686 1016 case CODEC_ID_ADPCM_IMA_DK4:
5c69a4fd
MN
1017 if (avctx->block_align != 0 && buf_size > avctx->block_align)
1018 buf_size = avctx->block_align;
1019
6cf9d5eb 1020 c->status[0].predictor = (int16_t)(src[0] | (src[1] << 8));
9937e686
MM
1021 c->status[0].step_index = src[2];
1022 src += 4;
9937e686
MM
1023 *samples++ = c->status[0].predictor;
1024 if (st) {
6cf9d5eb 1025 c->status[1].predictor = (int16_t)(src[0] | (src[1] << 8));
9937e686
MM
1026 c->status[1].step_index = src[2];
1027 src += 4;
9937e686
MM
1028 *samples++ = c->status[1].predictor;
1029 }
1030 while (src < buf + buf_size) {
1031
1032 /* take care of the top nibble (always left or mono channel) */
115329f1 1033 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1034 (src[0] >> 4) & 0x0F, 3);
9937e686
MM
1035
1036 /* take care of the bottom nibble, which is right sample for
1037 * stereo, or another mono sample */
1038 if (st)
115329f1 1039 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
d94728c3 1040 src[0] & 0x0F, 3);
9937e686 1041 else
115329f1 1042 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1043 src[0] & 0x0F, 3);
9937e686
MM
1044
1045 src++;
1046 }
1047 break;
1048 case CODEC_ID_ADPCM_IMA_DK3:
5c69a4fd
MN
1049 if (avctx->block_align != 0 && buf_size > avctx->block_align)
1050 buf_size = avctx->block_align;
1051
14c49573
MN
1052 if(buf_size + 16 > (samples_end - samples)*3/8)
1053 return -1;
1054
6cf9d5eb
MN
1055 c->status[0].predictor = (int16_t)(src[10] | (src[11] << 8));
1056 c->status[1].predictor = (int16_t)(src[12] | (src[13] << 8));
9937e686
MM
1057 c->status[0].step_index = src[14];
1058 c->status[1].step_index = src[15];
1059 /* sign extend the predictors */
9937e686
MM
1060 src += 16;
1061 diff_channel = c->status[1].predictor;
1062
1063 /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
1064 * the buffer is consumed */
1065 while (1) {
1066
1067 /* for this algorithm, c->status[0] is the sum channel and
1068 * c->status[1] is the diff channel */
1069
1070 /* process the first predictor of the sum channel */
1071 DK3_GET_NEXT_NIBBLE();
d94728c3 1072 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
9937e686
MM
1073
1074 /* process the diff channel predictor */
1075 DK3_GET_NEXT_NIBBLE();
d94728c3 1076 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
9937e686
MM
1077
1078 /* process the first pair of stereo PCM samples */
1079 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1080 *samples++ = c->status[0].predictor + c->status[1].predictor;
1081 *samples++ = c->status[0].predictor - c->status[1].predictor;
1082
1083 /* process the second predictor of the sum channel */
1084 DK3_GET_NEXT_NIBBLE();
d94728c3 1085 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
9937e686
MM
1086
1087 /* process the second pair of stereo PCM samples */
1088 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1089 *samples++ = c->status[0].predictor + c->status[1].predictor;
1090 *samples++ = c->status[0].predictor - c->status[1].predictor;
1091 }
1092 break;
2fdf638b
MM
1093 case CODEC_ID_ADPCM_IMA_WS:
1094 /* no per-block initialization; just start decoding the data */
1095 while (src < buf + buf_size) {
1096
1097 if (st) {
115329f1 1098 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1099 (src[0] >> 4) & 0x0F, 3);
115329f1 1100 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
d94728c3 1101 src[0] & 0x0F, 3);
2fdf638b 1102 } else {
115329f1 1103 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1104 (src[0] >> 4) & 0x0F, 3);
115329f1 1105 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1106 src[0] & 0x0F, 3);
2fdf638b
MM
1107 }
1108
1109 src++;
1110 }
1111 break;
fc384777 1112 case CODEC_ID_ADPCM_XA:
115329f1 1113 c->status[0].sample1 = c->status[0].sample2 =
fc384777
MM
1114 c->status[1].sample1 = c->status[1].sample2 = 0;
1115 while (buf_size >= 128) {
115329f1 1116 xa_decode(samples, src, &c->status[0], &c->status[1],
fc384777
MM
1117 avctx->channels);
1118 src += 128;
1119 samples += 28 * 8;
1120 buf_size -= 128;
1121 }
1122 break;
7d8379f2 1123 case CODEC_ID_ADPCM_EA:
fead30d4 1124 samples_in_chunk = AV_RL32(src);
7d8379f2
MM
1125 if (samples_in_chunk >= ((buf_size - 12) * 2)) {
1126 src += buf_size;
1127 break;
1128 }
1129 src += 4;
fead30d4 1130 current_left_sample = (int16_t)AV_RL16(src);
7d8379f2 1131 src += 2;
fead30d4 1132 previous_left_sample = (int16_t)AV_RL16(src);
7d8379f2 1133 src += 2;
fead30d4 1134 current_right_sample = (int16_t)AV_RL16(src);
7d8379f2 1135 src += 2;
fead30d4 1136 previous_right_sample = (int16_t)AV_RL16(src);
7d8379f2
MM
1137 src += 2;
1138
1139 for (count1 = 0; count1 < samples_in_chunk/28;count1++) {
1140 coeff1l = ea_adpcm_table[(*src >> 4) & 0x0F];
1141 coeff2l = ea_adpcm_table[((*src >> 4) & 0x0F) + 4];
1142 coeff1r = ea_adpcm_table[*src & 0x0F];
1143 coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
1144 src++;
1145
1146 shift_left = ((*src >> 4) & 0x0F) + 8;
1147 shift_right = (*src & 0x0F) + 8;
1148 src++;
1149
1150 for (count2 = 0; count2 < 28; count2++) {
1151 next_left_sample = (((*src & 0xF0) << 24) >> shift_left);
1152 next_right_sample = (((*src & 0x0F) << 28) >> shift_right);
1153 src++;
1154
115329f1
DB
1155 next_left_sample = (next_left_sample +
1156 (current_left_sample * coeff1l) +
7d8379f2 1157 (previous_left_sample * coeff2l) + 0x80) >> 8;
115329f1
DB
1158 next_right_sample = (next_right_sample +
1159 (current_right_sample * coeff1r) +
7d8379f2 1160 (previous_right_sample * coeff2r) + 0x80) >> 8;
7d8379f2
MM
1161
1162 previous_left_sample = current_left_sample;
295f3737 1163 current_left_sample = av_clip_int16(next_left_sample);
7d8379f2 1164 previous_right_sample = current_right_sample;
295f3737 1165 current_right_sample = av_clip_int16(next_right_sample);
7d8379f2
MM
1166 *samples++ = (unsigned short)current_left_sample;
1167 *samples++ = (unsigned short)current_right_sample;
1168 }
1169 }
1170 break;
1171 case CODEC_ID_ADPCM_IMA_SMJPEG:
1172 c->status[0].predictor = *src;
1173 src += 2;
1174 c->status[0].step_index = *src++;
1175 src++; /* skip another byte before getting to the meat */
1176 while (src < buf + buf_size) {
1177 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1178 *src & 0x0F, 3);
1179 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1180 (*src >> 4) & 0x0F, 3);
1181 src++;
1182 }
1183 break;
b3bfb299 1184 case CODEC_ID_ADPCM_CT:
bb270c08 1185 while (src < buf + buf_size) {
b3bfb299 1186 if (st) {
115329f1 1187 *samples++ = adpcm_ct_expand_nibble(&c->status[0],
b3bfb299 1188 (src[0] >> 4) & 0x0F);
115329f1 1189 *samples++ = adpcm_ct_expand_nibble(&c->status[1],
b3bfb299
MM
1190 src[0] & 0x0F);
1191 } else {
115329f1 1192 *samples++ = adpcm_ct_expand_nibble(&c->status[0],
b3bfb299 1193 (src[0] >> 4) & 0x0F);
115329f1 1194 *samples++ = adpcm_ct_expand_nibble(&c->status[0],
b3bfb299
MM
1195 src[0] & 0x0F);
1196 }
bb270c08 1197 src++;
b3bfb299
MM
1198 }
1199 break;
2433f24f
AJ
1200 case CODEC_ID_ADPCM_SBPRO_4:
1201 case CODEC_ID_ADPCM_SBPRO_3:
1202 case CODEC_ID_ADPCM_SBPRO_2:
1203 if (!c->status[0].step_index) {
1204 /* the first byte is a raw sample */
1205 *samples++ = 128 * (*src++ - 0x80);
1206 if (st)
1207 *samples++ = 128 * (*src++ - 0x80);
1208 c->status[0].step_index = 1;
1209 }
1210 if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) {
1211 while (src < buf + buf_size) {
1212 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1213 (src[0] >> 4) & 0x0F, 4, 0);
1214 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1215 src[0] & 0x0F, 4, 0);
1216 src++;
1217 }
1218 } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) {
14c49573 1219 while (src < buf + buf_size && samples + 2 < samples_end) {
2433f24f
AJ
1220 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1221 (src[0] >> 5) & 0x07, 3, 0);
1222 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1223 (src[0] >> 2) & 0x07, 3, 0);
1224 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1225 src[0] & 0x03, 2, 0);
1226 src++;
1227 }
1228 } else {
14c49573 1229 while (src < buf + buf_size && samples + 3 < samples_end) {
2433f24f
AJ
1230 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1231 (src[0] >> 6) & 0x03, 2, 2);
1232 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1233 (src[0] >> 4) & 0x03, 2, 2);
1234 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1235 (src[0] >> 2) & 0x03, 2, 2);
1236 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1237 src[0] & 0x03, 2, 2);
1238 src++;
1239 }
1240 }
1241 break;
659c3692
AB
1242 case CODEC_ID_ADPCM_SWF:
1243 {
bb270c08
DB
1244 GetBitContext gb;
1245 const int *table;
fe4ff07a 1246 int k0, signmask, nb_bits, count;
bb270c08
DB
1247 int size = buf_size*8;
1248
1249 init_get_bits(&gb, buf, size);
1250
90b5b51e 1251 //read bits & initial values
387afa9d
BC
1252 nb_bits = get_bits(&gb, 2)+2;
1253 //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits);
1254 table = swf_index_tables[nb_bits-2];
1255 k0 = 1 << (nb_bits-2);
1256 signmask = 1 << (nb_bits-1);
bb270c08 1257
fe4ff07a 1258 while (get_bits_count(&gb) <= size - 22*avctx->channels) {
387afa9d 1259 for (i = 0; i < avctx->channels; i++) {
d0fa156f
BC
1260 *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
1261 c->status[i].step_index = get_bits(&gb, 6);
1262 }
1263
1264 for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
1265 int i;
1266
1267 for (i = 0; i < avctx->channels; i++) {
1268 // similar to IMA adpcm
1269 int delta = get_bits(&gb, nb_bits);
1270 int step = step_table[c->status[i].step_index];
1271 long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
1272 int k = k0;
1273
1274 do {
1275 if (delta & k)
1276 vpdiff += step;
1277 step >>= 1;
1278 k >>= 1;
1279 } while(k);
1280 vpdiff += step;
1281
1282 if (delta & signmask)
1283 c->status[i].predictor -= vpdiff;
1284 else
1285 c->status[i].predictor += vpdiff;
1286
1287 c->status[i].step_index += table[delta & (~signmask)];
1288
1289 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
aee481ce 1290 c->status[i].predictor = av_clip_int16(c->status[i].predictor);
d0fa156f
BC
1291
1292 *samples++ = c->status[i].predictor;
1293 if (samples >= samples_end) {
1294 av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");
1295 return -1;
1296 }
387afa9d 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);
295f3737 1364 *samples = av_clip_int16(sampledat);
b736a365
MN
1365 prev[ch][1] = prev[ch][0];
1366 prev[ch][0] = *samples++;
d1e0d21f
MG
1367
1368 /* In case of stereo, skip one sample, this sample
1369 is for the other channel. */
1370 samples += st;
1371 }
1372 }
1373 }
1374
1375 /* In the previous loop, in case stereo is used, samples is
1376 increased exactly one time too often. */
1377 samples -= st;
1378 break;
90f2a1a0 1379 }
d1e0d21f 1380
0147f198 1381 default:
0147f198
FR
1382 return -1;
1383 }
0c1a9eda 1384 *data_size = (uint8_t *)samples - (uint8_t *)data;
0147f198
FR
1385 return src - buf;
1386}
1387
764ef400
MM
1388
1389
1390#ifdef CONFIG_ENCODERS
1391#define ADPCM_ENCODER(id,name) \
0147f198
FR
1392AVCodec name ## _encoder = { \
1393 #name, \
1394 CODEC_TYPE_AUDIO, \
1395 id, \
1396 sizeof(ADPCMContext), \
1397 adpcm_encode_init, \
1398 adpcm_encode_frame, \
1399 adpcm_encode_close, \
1400 NULL, \
764ef400
MM
1401};
1402#else
1403#define ADPCM_ENCODER(id,name)
1404#endif
1405
1406#ifdef CONFIG_DECODERS
1407#define ADPCM_DECODER(id,name) \
0147f198
FR
1408AVCodec name ## _decoder = { \
1409 #name, \
1410 CODEC_TYPE_AUDIO, \
1411 id, \
1412 sizeof(ADPCMContext), \
1413 adpcm_decode_init, \
1414 NULL, \
1415 NULL, \
1416 adpcm_decode_frame, \
1417};
764ef400
MM
1418#else
1419#define ADPCM_DECODER(id,name)
1420#endif
1421
1422#define ADPCM_CODEC(id, name) \
1423ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)
0147f198
FR
1424
1425ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
1426ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
9937e686
MM
1427ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);
1428ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);
2fdf638b 1429ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);
7d8379f2 1430ADPCM_CODEC(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
0147f198 1431ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
4b465299 1432ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm);
fc384777 1433ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa);
7d8379f2 1434ADPCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea);
b3bfb299 1435ADPCM_CODEC(CODEC_ID_ADPCM_CT, adpcm_ct);
659c3692 1436ADPCM_CODEC(CODEC_ID_ADPCM_SWF, adpcm_swf);
2ff4524e 1437ADPCM_CODEC(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha);
2433f24f
AJ
1438ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4);
1439ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3);
1440ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2);
d1e0d21f 1441ADPCM_CODEC(CODEC_ID_ADPCM_THP, adpcm_thp);
0147f198
FR
1442
1443#undef ADPCM_CODEC