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