fix decoding of samples.mplayerhq.hu/game-formats/idroq/demoEnd.roq
[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;
211 c->prev_sample = 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;
aee481ce 231 predictor = av_clip_int16(predictor);
6cf9d5eb
MN
232
233 c->sample2 = c->sample1;
234 c->sample1 = predictor;
235
236 c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
237 if (c->idelta < 16) c->idelta = 16;
238
239 return nibble;
240}
241
2ff4524e
VM
242static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, short sample)
243{
7e537051 244 int nibble, delta;
2ff4524e
VM
245
246 if(!c->step) {
247 c->predictor = 0;
248 c->step = 127;
249 }
2ff4524e 250
7e537051 251 delta = sample - c->predictor;
2ff4524e 252
7e537051
LM
253 nibble = FFMIN(7, abs(delta)*4/c->step) + (delta<0)*8;
254
255 c->predictor = c->predictor + ((c->step * yamaha_difflookup[nibble]) / 8);
aee481ce 256 c->predictor = av_clip_int16(c->predictor);
7e537051 257 c->step = (c->step * yamaha_indexscale[nibble]) >> 8;
f66e4f5f 258 c->step = av_clip(c->step, 127, 24567);
2ff4524e 259
7e537051 260 return nibble;
2ff4524e
VM
261}
262
696d6889
LM
263typedef struct TrellisPath {
264 int nibble;
265 int prev;
266} TrellisPath;
267
268typedef struct TrellisNode {
269 uint32_t ssd;
270 int path;
271 int sample1;
272 int sample2;
273 int step;
274} TrellisNode;
275
276static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
277 uint8_t *dst, ADPCMChannelStatus *c, int n)
278{
279#define FREEZE_INTERVAL 128
280 //FIXME 6% faster if frontier is a compile-time constant
281 const int frontier = 1 << avctx->trellis;
282 const int stride = avctx->channels;
283 const int version = avctx->codec->id;
284 const int max_paths = frontier*FREEZE_INTERVAL;
285 TrellisPath paths[max_paths], *p;
286 TrellisNode node_buf[2][frontier];
287 TrellisNode *nodep_buf[2][frontier];
288 TrellisNode **nodes = nodep_buf[0]; // nodes[] is always sorted by .ssd
289 TrellisNode **nodes_next = nodep_buf[1];
290 int pathn = 0, froze = -1, i, j, k;
291
292 assert(!(max_paths&(max_paths-1)));
293
294 memset(nodep_buf, 0, sizeof(nodep_buf));
295 nodes[0] = &node_buf[1][0];
296 nodes[0]->ssd = 0;
297 nodes[0]->path = 0;
298 nodes[0]->step = c->step_index;
299 nodes[0]->sample1 = c->sample1;
300 nodes[0]->sample2 = c->sample2;
301 if(version == CODEC_ID_ADPCM_IMA_WAV)
302 nodes[0]->sample1 = c->prev_sample;
303 if(version == CODEC_ID_ADPCM_MS)
304 nodes[0]->step = c->idelta;
305 if(version == CODEC_ID_ADPCM_YAMAHA) {
306 if(c->step == 0) {
307 nodes[0]->step = 127;
308 nodes[0]->sample1 = 0;
309 } else {
310 nodes[0]->step = c->step;
311 nodes[0]->sample1 = c->predictor;
312 }
313 }
314
315 for(i=0; i<n; i++) {
316 TrellisNode *t = node_buf[i&1];
317 TrellisNode **u;
318 int sample = samples[i*stride];
319 memset(nodes_next, 0, frontier*sizeof(TrellisNode*));
320 for(j=0; j<frontier && nodes[j]; j++) {
321 // higher j have higher ssd already, so they're unlikely to use a suboptimal next sample too
322 const int range = (j < frontier/2) ? 1 : 0;
323 const int step = nodes[j]->step;
324 int nidx;
325 if(version == CODEC_ID_ADPCM_MS) {
326 const int predictor = ((nodes[j]->sample1 * c->coeff1) + (nodes[j]->sample2 * c->coeff2)) / 256;
327 const int div = (sample - predictor) / step;
f66e4f5f
RD
328 const int nmin = av_clip(div-range, -8, 6);
329 const int nmax = av_clip(div+range, -7, 7);
696d6889
LM
330 for(nidx=nmin; nidx<=nmax; nidx++) {
331 const int nibble = nidx & 0xf;
332 int dec_sample = predictor + nidx * step;
333#define STORE_NODE(NAME, STEP_INDEX)\
334 int d;\
335 uint32_t ssd;\
aee481ce 336 dec_sample = av_clip_int16(dec_sample);\
696d6889
LM
337 d = sample - dec_sample;\
338 ssd = nodes[j]->ssd + d*d;\
339 if(nodes_next[frontier-1] && ssd >= nodes_next[frontier-1]->ssd)\
340 continue;\
341 /* Collapse any two states with the same previous sample value. \
342 * One could also distinguish states by step and by 2nd to last
343 * sample, but the effects of that are negligible. */\
344 for(k=0; k<frontier && nodes_next[k]; k++) {\
345 if(dec_sample == nodes_next[k]->sample1) {\
346 assert(ssd >= nodes_next[k]->ssd);\
347 goto next_##NAME;\
348 }\
349 }\
350 for(k=0; k<frontier; k++) {\
351 if(!nodes_next[k] || ssd < nodes_next[k]->ssd) {\
352 TrellisNode *u = nodes_next[frontier-1];\
353 if(!u) {\
354 assert(pathn < max_paths);\
355 u = t++;\
356 u->path = pathn++;\
357 }\
358 u->ssd = ssd;\
359 u->step = STEP_INDEX;\
360 u->sample2 = nodes[j]->sample1;\
361 u->sample1 = dec_sample;\
362 paths[u->path].nibble = nibble;\
363 paths[u->path].prev = nodes[j]->path;\
364 memmove(&nodes_next[k+1], &nodes_next[k], (frontier-k-1)*sizeof(TrellisNode*));\
365 nodes_next[k] = u;\
366 break;\
367 }\
368 }\
369 next_##NAME:;
370 STORE_NODE(ms, FFMAX(16, (AdaptationTable[nibble] * step) >> 8));
371 }
372 } else if(version == CODEC_ID_ADPCM_IMA_WAV) {
373#define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
374 const int predictor = nodes[j]->sample1;\
375 const int div = (sample - predictor) * 4 / STEP_TABLE;\
f66e4f5f
RD
376 int nmin = av_clip(div-range, -7, 6);\
377 int nmax = av_clip(div+range, -6, 7);\
696d6889
LM
378 if(nmin<=0) nmin--; /* distinguish -0 from +0 */\
379 if(nmax<0) nmax--;\
380 for(nidx=nmin; nidx<=nmax; nidx++) {\
381 const int nibble = nidx<0 ? 7-nidx : nidx;\
382 int dec_sample = predictor + (STEP_TABLE * yamaha_difflookup[nibble]) / 8;\
383 STORE_NODE(NAME, STEP_INDEX);\
384 }
f66e4f5f 385 LOOP_NODES(ima, step_table[step], av_clip(step + index_table[nibble], 0, 88));
696d6889 386 } else { //CODEC_ID_ADPCM_YAMAHA
f66e4f5f 387 LOOP_NODES(yamaha, step, av_clip((step * yamaha_indexscale[nibble]) >> 8, 127, 24567));
696d6889
LM
388#undef LOOP_NODES
389#undef STORE_NODE
390 }
391 }
392
393 u = nodes;
394 nodes = nodes_next;
395 nodes_next = u;
396
397 // prevent overflow
398 if(nodes[0]->ssd > (1<<28)) {
399 for(j=1; j<frontier && nodes[j]; j++)
400 nodes[j]->ssd -= nodes[0]->ssd;
401 nodes[0]->ssd = 0;
402 }
403
404 // merge old paths to save memory
405 if(i == froze + FREEZE_INTERVAL) {
406 p = &paths[nodes[0]->path];
407 for(k=i; k>froze; k--) {
408 dst[k] = p->nibble;
409 p = &paths[p->prev];
410 }
411 froze = i;
412 pathn = 0;
413 // other nodes might use paths that don't coincide with the frozen one.
414 // checking which nodes do so is too slow, so just kill them all.
415 // this also slightly improves quality, but I don't know why.
416 memset(nodes+1, 0, (frontier-1)*sizeof(TrellisNode*));
417 }
418 }
419
420 p = &paths[nodes[0]->path];
421 for(i=n-1; i>froze; i--) {
422 dst[i] = p->nibble;
423 p = &paths[p->prev];
424 }
425
426 c->predictor = nodes[0]->sample1;
427 c->sample1 = nodes[0]->sample1;
428 c->sample2 = nodes[0]->sample2;
429 c->step_index = nodes[0]->step;
430 c->step = nodes[0]->step;
431 c->idelta = nodes[0]->step;
432}
433
0147f198 434static int adpcm_encode_frame(AVCodecContext *avctx,
bb270c08 435 unsigned char *frame, int buf_size, void *data)
0147f198 436{
6cf9d5eb 437 int n, i, st;
0147f198
FR
438 short *samples;
439 unsigned char *dst;
889c5224
FR
440 ADPCMContext *c = avctx->priv_data;
441
442 dst = frame;
443 samples = (short *)data;
6cf9d5eb 444 st= avctx->channels == 2;
889c5224 445/* n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */
0147f198
FR
446
447 switch(avctx->codec->id) {
889c5224
FR
448 case CODEC_ID_ADPCM_IMA_QT: /* XXX: can't test until we get .mov writer */
449 break;
450 case CODEC_ID_ADPCM_IMA_WAV:
451 n = avctx->frame_size / 8;
452 c->status[0].prev_sample = (signed short)samples[0]; /* XXX */
453/* c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */
2c124cb6 454 bytestream_put_le16(&dst, c->status[0].prev_sample);
889c5224
FR
455 *dst++ = (unsigned char)c->status[0].step_index;
456 *dst++ = 0; /* unknown */
457 samples++;
458 if (avctx->channels == 2) {
1ffb0091 459 c->status[1].prev_sample = (signed short)samples[1];
889c5224 460/* c->status[1].step_index = 0; */
2c124cb6 461 bytestream_put_le16(&dst, c->status[1].prev_sample);
889c5224
FR
462 *dst++ = (unsigned char)c->status[1].step_index;
463 *dst++ = 0;
464 samples++;
465 }
115329f1 466
889c5224 467 /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */
696d6889
LM
468 if(avctx->trellis > 0) {
469 uint8_t buf[2][n*8];
470 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n*8);
471 if(avctx->channels == 2)
472 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n*8);
473 for(i=0; i<n; i++) {
474 *dst++ = buf[0][8*i+0] | (buf[0][8*i+1] << 4);
475 *dst++ = buf[0][8*i+2] | (buf[0][8*i+3] << 4);
476 *dst++ = buf[0][8*i+4] | (buf[0][8*i+5] << 4);
477 *dst++ = buf[0][8*i+6] | (buf[0][8*i+7] << 4);
478 if (avctx->channels == 2) {
479 *dst++ = buf[1][8*i+0] | (buf[1][8*i+1] << 4);
480 *dst++ = buf[1][8*i+2] | (buf[1][8*i+3] << 4);
481 *dst++ = buf[1][8*i+4] | (buf[1][8*i+5] << 4);
482 *dst++ = buf[1][8*i+6] | (buf[1][8*i+7] << 4);
483 }
484 }
485 } else
889c5224
FR
486 for (; n>0; n--) {
487 *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]) & 0x0F;
488 *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4) & 0xF0;
489 dst++;
490 *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]) & 0x0F;
491 *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4) & 0xF0;
492 dst++;
493 *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]) & 0x0F;
494 *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4) & 0xF0;
495 dst++;
496 *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]) & 0x0F;
497 *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4) & 0xF0;
498 dst++;
499 /* right channel */
500 if (avctx->channels == 2) {
501 *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]);
502 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4;
503 dst++;
504 *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]);
505 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4;
506 dst++;
507 *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]);
508 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;
509 dst++;
510 *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]);
511 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
512 dst++;
513 }
514 samples += 8 * avctx->channels;
515 }
516 break;
d64b88d4
BL
517 case CODEC_ID_ADPCM_SWF:
518 {
519 int i;
520 PutBitContext pb;
521 init_put_bits(&pb, dst, buf_size*8);
522
523 //Store AdpcmCodeSize
524 put_bits(&pb, 2, 2); //Set 4bits flash adpcm format
525
526 //Init the encoder state
527 for(i=0; i<avctx->channels; i++){
ac069107 528 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63); // clip step so it fits 6 bits
d64b88d4 529 put_bits(&pb, 16, samples[i] & 0xFFFF);
ac069107 530 put_bits(&pb, 6, c->status[i].step_index);
d64b88d4
BL
531 c->status[i].prev_sample = (signed short)samples[i];
532 }
533
00a254b7 534 for (i=1; i<avctx->frame_size; i++) {
d64b88d4
BL
535 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i]) & 0xF);
536 if (avctx->channels == 2)
537 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1]) & 0xF);
538 }
9fff16bc
BC
539 flush_put_bits(&pb);
540 dst += put_bits_count(&pb)>>3;
d64b88d4
BL
541 break;
542 }
6cf9d5eb
MN
543 case CODEC_ID_ADPCM_MS:
544 for(i=0; i<avctx->channels; i++){
545 int predictor=0;
546
547 *dst++ = predictor;
548 c->status[i].coeff1 = AdaptCoeff1[predictor];
549 c->status[i].coeff2 = AdaptCoeff2[predictor];
550 }
551 for(i=0; i<avctx->channels; i++){
115329f1 552 if (c->status[i].idelta < 16)
6cf9d5eb 553 c->status[i].idelta = 16;
115329f1 554
2c124cb6 555 bytestream_put_le16(&dst, c->status[i].idelta);
6cf9d5eb
MN
556 }
557 for(i=0; i<avctx->channels; i++){
558 c->status[i].sample1= *samples++;
559
2c124cb6 560 bytestream_put_le16(&dst, c->status[i].sample1);
6cf9d5eb
MN
561 }
562 for(i=0; i<avctx->channels; i++){
563 c->status[i].sample2= *samples++;
564
2c124cb6 565 bytestream_put_le16(&dst, c->status[i].sample2);
6cf9d5eb
MN
566 }
567
696d6889
LM
568 if(avctx->trellis > 0) {
569 int n = avctx->block_align - 7*avctx->channels;
570 uint8_t buf[2][n];
571 if(avctx->channels == 1) {
572 n *= 2;
573 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
574 for(i=0; i<n; i+=2)
575 *dst++ = (buf[0][i] << 4) | buf[0][i+1];
576 } else {
577 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
578 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
579 for(i=0; i<n; i++)
580 *dst++ = (buf[0][i] << 4) | buf[1][i];
581 }
582 } else
6cf9d5eb
MN
583 for(i=7*avctx->channels; i<avctx->block_align; i++) {
584 int nibble;
585 nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4;
586 nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++);
587 *dst++ = nibble;
588 }
589 break;
2ff4524e
VM
590 case CODEC_ID_ADPCM_YAMAHA:
591 n = avctx->frame_size / 2;
696d6889
LM
592 if(avctx->trellis > 0) {
593 uint8_t buf[2][n*2];
594 n *= 2;
595 if(avctx->channels == 1) {
596 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
597 for(i=0; i<n; i+=2)
598 *dst++ = buf[0][i] | (buf[0][i+1] << 4);
599 } else {
600 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n);
601 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n);
602 for(i=0; i<n; i++)
603 *dst++ = buf[0][i] | (buf[1][i] << 4);
604 }
605 } else
2ff4524e
VM
606 for (; n>0; n--) {
607 for(i = 0; i < avctx->channels; i++) {
608 int nibble;
b194c327
MN
609 nibble = adpcm_yamaha_compress_sample(&c->status[i], samples[i]);
610 nibble |= adpcm_yamaha_compress_sample(&c->status[i], samples[i+avctx->channels]) << 4;
2ff4524e
VM
611 *dst++ = nibble;
612 }
613 samples += 2 * avctx->channels;
614 }
615 break;
0147f198
FR
616 default:
617 return -1;
618 }
0147f198
FR
619 return dst - frame;
620}
764ef400 621#endif //CONFIG_ENCODERS
0147f198
FR
622
623static int adpcm_decode_init(AVCodecContext * avctx)
624{
625 ADPCMContext *c = avctx->priv_data;
626
14c49573
MN
627 if(avctx->channels > 2U){
628 return -1;
629 }
630
0147f198
FR
631 c->channel = 0;
632 c->status[0].predictor = c->status[1].predictor = 0;
633 c->status[0].step_index = c->status[1].step_index = 0;
634 c->status[0].step = c->status[1].step = 0;
635
636 switch(avctx->codec->id) {
b3bfb299 637 case CODEC_ID_ADPCM_CT:
bb270c08
DB
638 c->status[0].step = c->status[1].step = 511;
639 break;
8e952e4d
AH
640 case CODEC_ID_ADPCM_IMA_WS:
641 if (avctx->extradata && avctx->extradata_size == 2 * 4) {
642 c->status[0].predictor = AV_RL32(avctx->extradata);
643 c->status[1].predictor = AV_RL32(avctx->extradata + 4);
644 }
645 break;
0147f198
FR
646 default:
647 break;
648 }
649 return 0;
650}
651
d94728c3 652static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
0147f198
FR
653{
654 int step_index;
655 int predictor;
656 int sign, delta, diff, step;
657
135ee03a 658 step = step_table[c->step_index];
0147f198
FR
659 step_index = c->step_index + index_table[(unsigned)nibble];
660 if (step_index < 0) step_index = 0;
135ee03a 661 else if (step_index > 88) step_index = 88;
0147f198 662
0147f198
FR
663 sign = nibble & 8;
664 delta = nibble & 7;
9937e686
MM
665 /* perform direct multiplication instead of series of jumps proposed by
666 * the reference ADPCM implementation since modern CPUs can do the mults
667 * quickly enough */
d94728c3 668 diff = ((2 * delta + 1) * step) >> shift;
4b465299
MN
669 predictor = c->predictor;
670 if (sign) predictor -= diff;
671 else predictor += diff;
672
aee481ce 673 predictor = av_clip_int16(predictor);
4b465299
MN
674 c->predictor = predictor;
675 c->step_index = step_index;
676
677 return (short)predictor;
678}
679
0147f198
FR
680static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
681{
682 int predictor;
683
684 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
685 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
aee481ce 686 predictor = av_clip_int16(predictor);
0147f198
FR
687
688 c->sample2 = c->sample1;
689 c->sample1 = predictor;
6cf9d5eb 690 c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8;
0147f198
FR
691 if (c->idelta < 16) c->idelta = 16;
692
693 return (short)predictor;
694}
695
b3bfb299
MM
696static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)
697{
698 int predictor;
699 int sign, delta, diff;
700 int new_step;
701
702 sign = nibble & 8;
703 delta = nibble & 7;
704 /* perform direct multiplication instead of series of jumps proposed by
705 * the reference ADPCM implementation since modern CPUs can do the mults
706 * quickly enough */
707 diff = ((2 * delta + 1) * c->step) >> 3;
708 predictor = c->predictor;
709 /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
710 if(sign)
bb270c08 711 predictor = ((predictor * 254) >> 8) - diff;
b3bfb299 712 else
bb270c08 713 predictor = ((predictor * 254) >> 8) + diff;
b3bfb299
MM
714 /* calculate new step and clamp it to range 511..32767 */
715 new_step = (ct_adpcm_table[nibble & 7] * c->step) >> 8;
716 c->step = new_step;
717 if(c->step < 511)
bb270c08 718 c->step = 511;
b3bfb299 719 if(c->step > 32767)
bb270c08 720 c->step = 32767;
b3bfb299 721
aee481ce 722 predictor = av_clip_int16(predictor);
b3bfb299
MM
723 c->predictor = predictor;
724 return (short)predictor;
725}
726
2433f24f
AJ
727static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)
728{
729 int sign, delta, diff;
730
731 sign = nibble & (1<<(size-1));
732 delta = nibble & ((1<<(size-1))-1);
733 diff = delta << (7 + c->step + shift);
734
735 if (sign)
736 c->predictor -= diff;
737 else
738 c->predictor += diff;
739
740 /* clamp result */
741 if (c->predictor > 16256)
742 c->predictor = 16256;
743 else if (c->predictor < -16384)
744 c->predictor = -16384;
745
746 /* calculate new step */
747 if (delta >= (2*size - 3) && c->step < 3)
748 c->step++;
749 else if (delta == 0 && c->step > 0)
750 c->step--;
751
752 return (short) c->predictor;
753}
754
2ff4524e
VM
755static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)
756{
757 if(!c->step) {
758 c->predictor = 0;
759 c->step = 127;
760 }
761
762 c->predictor += (c->step * yamaha_difflookup[nibble]) / 8;
aee481ce 763 c->predictor = av_clip_int16(c->predictor);
2ff4524e 764 c->step = (c->step * yamaha_indexscale[nibble]) >> 8;
f66e4f5f 765 c->step = av_clip(c->step, 127, 24567);
2ff4524e
VM
766 return c->predictor;
767}
768
115329f1 769static void xa_decode(short *out, const unsigned char *in,
fc384777
MM
770 ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
771{
772 int i, j;
773 int shift,filter,f0,f1;
774 int s_1,s_2;
775 int d,s,t;
776
777 for(i=0;i<4;i++) {
778
779 shift = 12 - (in[4+i*2] & 15);
780 filter = in[4+i*2] >> 4;
781 f0 = xa_adpcm_table[filter][0];
782 f1 = xa_adpcm_table[filter][1];
783
784 s_1 = left->sample1;
785 s_2 = left->sample2;
786
787 for(j=0;j<28;j++) {
788 d = in[16+i+j*4];
789
790 t = (signed char)(d<<4)>>4;
791 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
aee481ce 792 s = av_clip_int16(s);
fc384777
MM
793 *out = s;
794 out += inc;
795 s_2 = s_1;
796 s_1 = s;
797 }
798
799 if (inc==2) { /* stereo */
800 left->sample1 = s_1;
801 left->sample2 = s_2;
802 s_1 = right->sample1;
803 s_2 = right->sample2;
804 out = out + 1 - 28*2;
805 }
806
807 shift = 12 - (in[5+i*2] & 15);
808 filter = in[5+i*2] >> 4;
809
810 f0 = xa_adpcm_table[filter][0];
811 f1 = xa_adpcm_table[filter][1];
812
813 for(j=0;j<28;j++) {
814 d = in[16+i+j*4];
815
816 t = (signed char)d >> 4;
817 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
aee481ce 818 s = av_clip_int16(s);
fc384777
MM
819 *out = s;
820 out += inc;
821 s_2 = s_1;
822 s_1 = s;
823 }
824
825 if (inc==2) { /* stereo */
826 right->sample1 = s_1;
827 right->sample2 = s_2;
828 out -= 1;
829 } else {
830 left->sample1 = s_1;
831 left->sample2 = s_2;
832 }
833 }
834}
835
836
9937e686
MM
837/* DK3 ADPCM support macro */
838#define DK3_GET_NEXT_NIBBLE() \
839 if (decode_top_nibble_next) \
840 { \
841 nibble = (last_byte >> 4) & 0x0F; \
842 decode_top_nibble_next = 0; \
843 } \
844 else \
845 { \
846 last_byte = *src++; \
847 if (src >= buf + buf_size) break; \
848 nibble = last_byte & 0x0F; \
849 decode_top_nibble_next = 1; \
850 }
851
0147f198 852static int adpcm_decode_frame(AVCodecContext *avctx,
bb270c08
DB
853 void *data, int *data_size,
854 uint8_t *buf, int buf_size)
0147f198
FR
855{
856 ADPCMContext *c = avctx->priv_data;
857 ADPCMChannelStatus *cs;
4b465299 858 int n, m, channel, i;
0147f198
FR
859 int block_predictor[2];
860 short *samples;
14c49573 861 short *samples_end;
0c1a9eda 862 uint8_t *src;
0147f198
FR
863 int st; /* stereo */
864
9937e686
MM
865 /* DK3 ADPCM accounting variables */
866 unsigned char last_byte = 0;
867 unsigned char nibble;
868 int decode_top_nibble_next = 0;
869 int diff_channel;
870
7d8379f2
MM
871 /* EA ADPCM state variables */
872 uint32_t samples_in_chunk;
873 int32_t previous_left_sample, previous_right_sample;
874 int32_t current_left_sample, current_right_sample;
875 int32_t next_left_sample, next_right_sample;
876 int32_t coeff1l, coeff2l, coeff1r, coeff2r;
877 uint8_t shift_left, shift_right;
878 int count1, count2;
879
df72754d
MM
880 if (!buf_size)
881 return 0;
882
14c49573
MN
883 //should protect all 4bit ADPCM variants
884 //8 is needed for CODEC_ID_ADPCM_IMA_WAV with 2 channels
885 //
886 if(*data_size/4 < buf_size + 8)
887 return -1;
888
0147f198 889 samples = data;
14c49573
MN
890 samples_end= samples + *data_size/2;
891 *data_size= 0;
0147f198
FR
892 src = buf;
893
2433f24f 894 st = avctx->channels == 2 ? 1 : 0;
0147f198
FR
895
896 switch(avctx->codec->id) {
897 case CODEC_ID_ADPCM_IMA_QT:
898 n = (buf_size - 2);/* >> 2*avctx->channels;*/
899 channel = c->channel;
900 cs = &(c->status[channel]);
901 /* (pppppp) (piiiiiii) */
902
903 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
904 cs->predictor = (*src++) << 8;
905 cs->predictor |= (*src & 0x80);
906 cs->predictor &= 0xFF80;
907
908 /* sign extension */
909 if(cs->predictor & 0x8000)
910 cs->predictor -= 0x10000;
911
aee481ce 912 cs->predictor = av_clip_int16(cs->predictor);
0147f198
FR
913
914 cs->step_index = (*src++) & 0x7F;
915
8d359bba
MN
916 if (cs->step_index > 88){
917 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
918 cs->step_index = 88;
919 }
0147f198
FR
920
921 cs->step = step_table[cs->step_index];
922
923 if (st && channel)
924 samples++;
925
926 for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
d94728c3 927 *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3);
0147f198 928 samples += avctx->channels;
d94728c3 929 *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F, 3);
0147f198
FR
930 samples += avctx->channels;
931 src ++;
932 }
933
934 if(st) { /* handle stereo interlacing */
935 c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
ac3d5cac 936 if(channel == 1) { /* wait for the other packet before outputing anything */
0147f198
FR
937 return src - buf;
938 }
939 }
940 break;
941 case CODEC_ID_ADPCM_IMA_WAV:
ca1d62f4
AY
942 if (avctx->block_align != 0 && buf_size > avctx->block_align)
943 buf_size = avctx->block_align;
944
8d359bba
MN
945// samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1;
946
d94728c3
MN
947 for(i=0; i<avctx->channels; i++){
948 cs = &(c->status[i]);
8d359bba
MN
949 cs->predictor = (int16_t)(src[0] + (src[1]<<8));
950 src+=2;
0147f198 951
bb270c08 952 // XXX: is this correct ??: *samples++ = cs->predictor;
889c5224 953
d94728c3 954 cs->step_index = *src++;
8d359bba
MN
955 if (cs->step_index > 88){
956 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
957 cs->step_index = 88;
958 }
959 if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */
0147f198 960 }
0147f198 961
8d359bba
MN
962 while(src < buf + buf_size){
963 for(m=0; m<4; m++){
964 for(i=0; i<=st; i++)
965 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3);
966 for(i=0; i<=st; i++)
967 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4 , 3);
968 src++;
bb270c08 969 }
8d359bba 970 src += 4*st;
bb270c08 971 }
0147f198 972 break;
4b465299
MN
973 case CODEC_ID_ADPCM_4XM:
974 cs = &(c->status[0]);
975 c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
976 if(st){
977 c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
978 }
979 c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
980 if(st){
981 c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
982 }
ac3d5cac
MM
983 if (cs->step_index < 0) cs->step_index = 0;
984 if (cs->step_index > 88) cs->step_index = 88;
4b465299
MN
985
986 m= (buf_size - (src - buf))>>st;
4b465299 987 for(i=0; i<m; i++) {
bb270c08 988 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);
4b465299 989 if (st)
d94728c3
MN
990 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);
991 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);
bb270c08 992 if (st)
d94728c3 993 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);
bb270c08 994 }
4b465299
MN
995
996 src += m<<st;
997
998 break;
0147f198 999 case CODEC_ID_ADPCM_MS:
ca1d62f4
AY
1000 if (avctx->block_align != 0 && buf_size > avctx->block_align)
1001 buf_size = avctx->block_align;
0147f198
FR
1002 n = buf_size - 7 * avctx->channels;
1003 if (n < 0)
1004 return -1;
f66e4f5f 1005 block_predictor[0] = av_clip(*src++, 0, 7);
0147f198
FR
1006 block_predictor[1] = 0;
1007 if (st)
f66e4f5f 1008 block_predictor[1] = av_clip(*src++, 0, 7);
6cf9d5eb 1009 c->status[0].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
0147f198 1010 src+=2;
6cf9d5eb
MN
1011 if (st){
1012 c->status[1].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
0147f198 1013 src+=2;
6cf9d5eb 1014 }
0147f198
FR
1015 c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
1016 c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
1017 c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
1018 c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
115329f1 1019
0147f198
FR
1020 c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1021 src+=2;
1022 if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1023 if (st) src+=2;
1024 c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1025 src+=2;
1026 if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
1027 if (st) src+=2;
1028
1029 *samples++ = c->status[0].sample1;
1030 if (st) *samples++ = c->status[1].sample1;
1031 *samples++ = c->status[0].sample2;
1032 if (st) *samples++ = c->status[1].sample2;
1033 for(;n>0;n--) {
1034 *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
1035 *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
1036 src ++;
1037 }
1038 break;
9937e686 1039 case CODEC_ID_ADPCM_IMA_DK4:
5c69a4fd
MN
1040 if (avctx->block_align != 0 && buf_size > avctx->block_align)
1041 buf_size = avctx->block_align;
1042
6cf9d5eb 1043 c->status[0].predictor = (int16_t)(src[0] | (src[1] << 8));
9937e686
MM
1044 c->status[0].step_index = src[2];
1045 src += 4;
9937e686
MM
1046 *samples++ = c->status[0].predictor;
1047 if (st) {
6cf9d5eb 1048 c->status[1].predictor = (int16_t)(src[0] | (src[1] << 8));
9937e686
MM
1049 c->status[1].step_index = src[2];
1050 src += 4;
9937e686
MM
1051 *samples++ = c->status[1].predictor;
1052 }
1053 while (src < buf + buf_size) {
1054
1055 /* take care of the top nibble (always left or mono channel) */
115329f1 1056 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1057 (src[0] >> 4) & 0x0F, 3);
9937e686
MM
1058
1059 /* take care of the bottom nibble, which is right sample for
1060 * stereo, or another mono sample */
1061 if (st)
115329f1 1062 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
d94728c3 1063 src[0] & 0x0F, 3);
9937e686 1064 else
115329f1 1065 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1066 src[0] & 0x0F, 3);
9937e686
MM
1067
1068 src++;
1069 }
1070 break;
1071 case CODEC_ID_ADPCM_IMA_DK3:
5c69a4fd
MN
1072 if (avctx->block_align != 0 && buf_size > avctx->block_align)
1073 buf_size = avctx->block_align;
1074
14c49573
MN
1075 if(buf_size + 16 > (samples_end - samples)*3/8)
1076 return -1;
1077
6cf9d5eb
MN
1078 c->status[0].predictor = (int16_t)(src[10] | (src[11] << 8));
1079 c->status[1].predictor = (int16_t)(src[12] | (src[13] << 8));
9937e686
MM
1080 c->status[0].step_index = src[14];
1081 c->status[1].step_index = src[15];
1082 /* sign extend the predictors */
9937e686
MM
1083 src += 16;
1084 diff_channel = c->status[1].predictor;
1085
1086 /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
1087 * the buffer is consumed */
1088 while (1) {
1089
1090 /* for this algorithm, c->status[0] is the sum channel and
1091 * c->status[1] is the diff channel */
1092
1093 /* process the first predictor of the sum channel */
1094 DK3_GET_NEXT_NIBBLE();
d94728c3 1095 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
9937e686
MM
1096
1097 /* process the diff channel predictor */
1098 DK3_GET_NEXT_NIBBLE();
d94728c3 1099 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
9937e686
MM
1100
1101 /* process the first 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 /* process the second predictor of the sum channel */
1107 DK3_GET_NEXT_NIBBLE();
d94728c3 1108 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
9937e686
MM
1109
1110 /* process the second pair of stereo PCM samples */
1111 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1112 *samples++ = c->status[0].predictor + c->status[1].predictor;
1113 *samples++ = c->status[0].predictor - c->status[1].predictor;
1114 }
1115 break;
2fdf638b
MM
1116 case CODEC_ID_ADPCM_IMA_WS:
1117 /* no per-block initialization; just start decoding the data */
1118 while (src < buf + buf_size) {
1119
1120 if (st) {
115329f1 1121 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1122 (src[0] >> 4) & 0x0F, 3);
115329f1 1123 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
d94728c3 1124 src[0] & 0x0F, 3);
2fdf638b 1125 } else {
115329f1 1126 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1127 (src[0] >> 4) & 0x0F, 3);
115329f1 1128 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 1129 src[0] & 0x0F, 3);
2fdf638b
MM
1130 }
1131
1132 src++;
1133 }
1134 break;
fc384777 1135 case CODEC_ID_ADPCM_XA:
115329f1 1136 c->status[0].sample1 = c->status[0].sample2 =
fc384777
MM
1137 c->status[1].sample1 = c->status[1].sample2 = 0;
1138 while (buf_size >= 128) {
115329f1 1139 xa_decode(samples, src, &c->status[0], &c->status[1],
fc384777
MM
1140 avctx->channels);
1141 src += 128;
1142 samples += 28 * 8;
1143 buf_size -= 128;
1144 }
1145 break;
7d8379f2 1146 case CODEC_ID_ADPCM_EA:
fead30d4 1147 samples_in_chunk = AV_RL32(src);
7d8379f2
MM
1148 if (samples_in_chunk >= ((buf_size - 12) * 2)) {
1149 src += buf_size;
1150 break;
1151 }
1152 src += 4;
fead30d4 1153 current_left_sample = (int16_t)AV_RL16(src);
7d8379f2 1154 src += 2;
fead30d4 1155 previous_left_sample = (int16_t)AV_RL16(src);
7d8379f2 1156 src += 2;
fead30d4 1157 current_right_sample = (int16_t)AV_RL16(src);
7d8379f2 1158 src += 2;
fead30d4 1159 previous_right_sample = (int16_t)AV_RL16(src);
7d8379f2
MM
1160 src += 2;
1161
1162 for (count1 = 0; count1 < samples_in_chunk/28;count1++) {
1163 coeff1l = ea_adpcm_table[(*src >> 4) & 0x0F];
1164 coeff2l = ea_adpcm_table[((*src >> 4) & 0x0F) + 4];
1165 coeff1r = ea_adpcm_table[*src & 0x0F];
1166 coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
1167 src++;
1168
1169 shift_left = ((*src >> 4) & 0x0F) + 8;
1170 shift_right = (*src & 0x0F) + 8;
1171 src++;
1172
1173 for (count2 = 0; count2 < 28; count2++) {
1174 next_left_sample = (((*src & 0xF0) << 24) >> shift_left);
1175 next_right_sample = (((*src & 0x0F) << 28) >> shift_right);
1176 src++;
1177
115329f1
DB
1178 next_left_sample = (next_left_sample +
1179 (current_left_sample * coeff1l) +
7d8379f2 1180 (previous_left_sample * coeff2l) + 0x80) >> 8;
115329f1
DB
1181 next_right_sample = (next_right_sample +
1182 (current_right_sample * coeff1r) +
7d8379f2 1183 (previous_right_sample * coeff2r) + 0x80) >> 8;
aee481ce
AJ
1184 next_left_sample = av_clip_int16(next_left_sample);
1185 next_right_sample = av_clip_int16(next_right_sample);
7d8379f2
MM
1186
1187 previous_left_sample = current_left_sample;
1188 current_left_sample = next_left_sample;
1189 previous_right_sample = current_right_sample;
1190 current_right_sample = next_right_sample;
1191 *samples++ = (unsigned short)current_left_sample;
1192 *samples++ = (unsigned short)current_right_sample;
1193 }
1194 }
1195 break;
1196 case CODEC_ID_ADPCM_IMA_SMJPEG:
1197 c->status[0].predictor = *src;
1198 src += 2;
1199 c->status[0].step_index = *src++;
1200 src++; /* skip another byte before getting to the meat */
1201 while (src < buf + buf_size) {
1202 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1203 *src & 0x0F, 3);
1204 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
1205 (*src >> 4) & 0x0F, 3);
1206 src++;
1207 }
1208 break;
b3bfb299 1209 case CODEC_ID_ADPCM_CT:
bb270c08 1210 while (src < buf + buf_size) {
b3bfb299 1211 if (st) {
115329f1 1212 *samples++ = adpcm_ct_expand_nibble(&c->status[0],
b3bfb299 1213 (src[0] >> 4) & 0x0F);
115329f1 1214 *samples++ = adpcm_ct_expand_nibble(&c->status[1],
b3bfb299
MM
1215 src[0] & 0x0F);
1216 } else {
115329f1 1217 *samples++ = adpcm_ct_expand_nibble(&c->status[0],
b3bfb299 1218 (src[0] >> 4) & 0x0F);
115329f1 1219 *samples++ = adpcm_ct_expand_nibble(&c->status[0],
b3bfb299
MM
1220 src[0] & 0x0F);
1221 }
bb270c08 1222 src++;
b3bfb299
MM
1223 }
1224 break;
2433f24f
AJ
1225 case CODEC_ID_ADPCM_SBPRO_4:
1226 case CODEC_ID_ADPCM_SBPRO_3:
1227 case CODEC_ID_ADPCM_SBPRO_2:
1228 if (!c->status[0].step_index) {
1229 /* the first byte is a raw sample */
1230 *samples++ = 128 * (*src++ - 0x80);
1231 if (st)
1232 *samples++ = 128 * (*src++ - 0x80);
1233 c->status[0].step_index = 1;
1234 }
1235 if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) {
1236 while (src < buf + buf_size) {
1237 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1238 (src[0] >> 4) & 0x0F, 4, 0);
1239 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1240 src[0] & 0x0F, 4, 0);
1241 src++;
1242 }
1243 } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) {
14c49573 1244 while (src < buf + buf_size && samples + 2 < samples_end) {
2433f24f
AJ
1245 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1246 (src[0] >> 5) & 0x07, 3, 0);
1247 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1248 (src[0] >> 2) & 0x07, 3, 0);
1249 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1250 src[0] & 0x03, 2, 0);
1251 src++;
1252 }
1253 } else {
14c49573 1254 while (src < buf + buf_size && samples + 3 < samples_end) {
2433f24f
AJ
1255 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1256 (src[0] >> 6) & 0x03, 2, 2);
1257 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1258 (src[0] >> 4) & 0x03, 2, 2);
1259 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1260 (src[0] >> 2) & 0x03, 2, 2);
1261 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1262 src[0] & 0x03, 2, 2);
1263 src++;
1264 }
1265 }
1266 break;
659c3692
AB
1267 case CODEC_ID_ADPCM_SWF:
1268 {
bb270c08
DB
1269 GetBitContext gb;
1270 const int *table;
fe4ff07a 1271 int k0, signmask, nb_bits, count;
bb270c08
DB
1272 int size = buf_size*8;
1273
1274 init_get_bits(&gb, buf, size);
1275
90b5b51e 1276 //read bits & initial values
387afa9d
BC
1277 nb_bits = get_bits(&gb, 2)+2;
1278 //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits);
1279 table = swf_index_tables[nb_bits-2];
1280 k0 = 1 << (nb_bits-2);
1281 signmask = 1 << (nb_bits-1);
bb270c08 1282
fe4ff07a 1283 while (get_bits_count(&gb) <= size - 22*avctx->channels) {
387afa9d 1284 for (i = 0; i < avctx->channels; i++) {
d0fa156f
BC
1285 *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
1286 c->status[i].step_index = get_bits(&gb, 6);
1287 }
1288
1289 for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {
1290 int i;
1291
1292 for (i = 0; i < avctx->channels; i++) {
1293 // similar to IMA adpcm
1294 int delta = get_bits(&gb, nb_bits);
1295 int step = step_table[c->status[i].step_index];
1296 long vpdiff = 0; // vpdiff = (delta+0.5)*step/4
1297 int k = k0;
1298
1299 do {
1300 if (delta & k)
1301 vpdiff += step;
1302 step >>= 1;
1303 k >>= 1;
1304 } while(k);
1305 vpdiff += step;
1306
1307 if (delta & signmask)
1308 c->status[i].predictor -= vpdiff;
1309 else
1310 c->status[i].predictor += vpdiff;
1311
1312 c->status[i].step_index += table[delta & (~signmask)];
1313
1314 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
aee481ce 1315 c->status[i].predictor = av_clip_int16(c->status[i].predictor);
d0fa156f
BC
1316
1317 *samples++ = c->status[i].predictor;
1318 if (samples >= samples_end) {
1319 av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");
1320 return -1;
1321 }
387afa9d 1322 }
bb270c08
DB
1323 }
1324 }
387afa9d 1325 src += buf_size;
bb270c08 1326 break;
659c3692 1327 }
2ff4524e
VM
1328 case CODEC_ID_ADPCM_YAMAHA:
1329 while (src < buf + buf_size) {
1330 if (st) {
1331 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
2ff4524e 1332 src[0] & 0x0F);
b194c327 1333 *samples++ = adpcm_yamaha_expand_nibble(&c->status[1],
2ff4524e 1334 (src[0] >> 4) & 0x0F);
b194c327 1335 } else {
2ff4524e
VM
1336 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
1337 src[0] & 0x0F);
b194c327
MN
1338 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
1339 (src[0] >> 4) & 0x0F);
2ff4524e
VM
1340 }
1341 src++;
1342 }
1343 break;
d1e0d21f 1344 case CODEC_ID_ADPCM_THP:
90f2a1a0 1345 {
20f75707 1346 int table[2][16];
d1e0d21f 1347 unsigned int samplecnt;
b736a365 1348 int prev[2][2];
d1e0d21f
MG
1349 int ch;
1350
1351 if (buf_size < 80) {
1352 av_log(avctx, AV_LOG_ERROR, "frame too small\n");
1353 return -1;
1354 }
1355
949ed6bb
MN
1356 src+=4;
1357 samplecnt = bytestream_get_be32(&src);
d1e0d21f 1358
11d66266 1359 for (i = 0; i < 32; i++)
949ed6bb 1360 table[0][i] = (int16_t)bytestream_get_be16(&src);
d1e0d21f
MG
1361
1362 /* Initialize the previous sample. */
204424a4 1363 for (i = 0; i < 4; i++)
949ed6bb 1364 prev[0][i] = (int16_t)bytestream_get_be16(&src);
d1e0d21f
MG
1365
1366 if (samplecnt >= (samples_end - samples) / (st + 1)) {
1367 av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n");
1368 return -1;
1369 }
1370
1371 for (ch = 0; ch <= st; ch++) {
1372 samples = (unsigned short *) data + ch;
1373
1374 /* Read in every sample for this channel. */
1375 for (i = 0; i < samplecnt / 14; i++) {
949ed6bb
MN
1376 int index = (*src >> 4) & 7;
1377 unsigned int exp = 28 - (*src++ & 15);
20f75707
MN
1378 int factor1 = table[ch][index * 2];
1379 int factor2 = table[ch][index * 2 + 1];
d1e0d21f
MG
1380
1381 /* Decode 14 samples. */
1382 for (n = 0; n < 14; n++) {
949ed6bb
MN
1383 int32_t sampledat;
1384 if(n&1) sampledat= *src++ <<28;
1385 else sampledat= (*src&0xF0)<<24;
d1e0d21f 1386
e457023a 1387 sampledat = ((prev[ch][0]*factor1
949ed6bb 1388 + prev[ch][1]*factor2) >> 11) + (sampledat>>exp);
aee481ce 1389 sampledat = av_clip_int16(sampledat);
e457023a 1390 *samples = 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
FR
1450
1451ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
1452ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
9937e686
MM
1453ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);
1454ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);
2fdf638b 1455ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);
7d8379f2 1456ADPCM_CODEC(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
0147f198 1457ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
4b465299 1458ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm);
fc384777 1459ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa);
7d8379f2 1460ADPCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea);
b3bfb299 1461ADPCM_CODEC(CODEC_ID_ADPCM_CT, adpcm_ct);
659c3692 1462ADPCM_CODEC(CODEC_ID_ADPCM_SWF, adpcm_swf);
2ff4524e 1463ADPCM_CODEC(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha);
2433f24f
AJ
1464ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4);
1465ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3);
1466ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2);
d1e0d21f 1467ADPCM_CODEC(CODEC_ID_ADPCM_THP, adpcm_thp);
0147f198
FR
1468
1469#undef ADPCM_CODEC