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