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