segfault fix
[libav.git] / libavcodec / adpcm.c
CommitLineData
0147f198
FR
1/*
2 * ADPCM codecs
9937e686 3 * Copyright (c) 2001-2003 The ffmpeg Project
0147f198
FR
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19#include "avcodec.h"
20
983e3246
MN
21/**
22 * @file adpcm.c
23 * ADPCM codecs.
fc384777 24 * First version by Francois Revol (revol@free.fr)
2fdf638b 25 * Fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
9937e686 26 * by Mike Melanson (melanson@pcisys.net)
fc384777 27 * CD-ROM XA ADPCM codec by BERO
7d8379f2 28 * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com)
0147f198
FR
29 *
30 * Features and limitations:
31 *
32 * Reference documents:
9937e686 33 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html
0147f198
FR
34 * http://www.geocities.com/SiliconValley/8682/aud3.txt
35 * http://openquicktime.sourceforge.net/plugins.htm
36 * XAnim sources (xa_codec.c) http://www.rasnaimaging.com/people/lapus/download.html
889c5224
FR
37 * http://www.cs.ucla.edu/~leec/mediabench/applications.html
38 * SoX source code http://home.sprynet.com/~cbagwell/sox.html
fc384777
MM
39 *
40 * CD-ROM XA:
41 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html
42 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html
43 * readstr http://www.geocities.co.jp/Playtown/2004/
0147f198
FR
44 */
45
46#define BLKSIZE 1024
47
7d8379f2
MM
48#define BE_16(x) ((((uint8_t*)(x))[0] << 8) | ((uint8_t*)(x))[1])
49#define LE_16(x) ((((uint8_t*)(x))[1] << 8) | ((uint8_t*)(x))[0])
50#define LE_32(x) ((((uint8_t*)(x))[3] << 24) | \
51 (((uint8_t*)(x))[2] << 16) | \
52 (((uint8_t*)(x))[1] << 8) | \
53 ((uint8_t*)(x))[0])
54
0147f198
FR
55#define CLAMP_TO_SHORT(value) \
56if (value > 32767) \
57 value = 32767; \
58else if (value < -32768) \
59 value = -32768; \
60
61/* step_table[] and index_table[] are from the ADPCM reference source */
62/* This is the index table: */
135ee03a 63static const int index_table[16] = {
0147f198
FR
64 -1, -1, -1, -1, 2, 4, 6, 8,
65 -1, -1, -1, -1, 2, 4, 6, 8,
66};
67
983e3246
MN
68/**
69 * This is the step table. Note that many programs use slight deviations from
0147f198
FR
70 * this table, but such deviations are negligible:
71 */
135ee03a 72static const int step_table[89] = {
0147f198
FR
73 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
74 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
75 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
76 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
77 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
78 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
79 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
80 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
81 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
82};
83
fc384777 84/* These are for MS-ADPCM */
0147f198 85/* AdaptationTable[], AdaptCoeff1[], and AdaptCoeff2[] are from libsndfile */
135ee03a 86static const int AdaptationTable[] = {
0147f198
FR
87 230, 230, 230, 230, 307, 409, 512, 614,
88 768, 614, 512, 409, 307, 230, 230, 230
89};
90
135ee03a 91static const int AdaptCoeff1[] = {
0147f198
FR
92 256, 512, 0, 192, 240, 460, 392
93};
94
135ee03a 95static const int AdaptCoeff2[] = {
0147f198
FR
96 0, -256, 0, 64, 0, -208, -232
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
7d8379f2
MM
108static int ea_adpcm_table[] = {
109 0, 240, 460, 392, 0, 0, -208, -220, 0, 1,
110 3, 4, 7, 8, 10, 11, 0, -1, -3, -4
111};
112
0147f198
FR
113/* end of tables */
114
115typedef struct ADPCMChannelStatus {
116 int predictor;
117 short int step_index;
118 int step;
889c5224
FR
119 /* for encoding */
120 int prev_sample;
0147f198
FR
121
122 /* MS version */
123 short sample1;
124 short sample2;
125 int coeff1;
126 int coeff2;
127 int idelta;
128} ADPCMChannelStatus;
129
130typedef struct ADPCMContext {
131 int channel; /* for stereo MOVs, decode left, then decode right, then tell it's decoded */
132 ADPCMChannelStatus status[2];
133 short sample_buffer[32]; /* hold left samples while waiting for right samples */
134} ADPCMContext;
135
136/* XXX: implement encoding */
137
764ef400 138#ifdef CONFIG_ENCODERS
0147f198
FR
139static int adpcm_encode_init(AVCodecContext *avctx)
140{
889c5224
FR
141 if (avctx->channels > 2)
142 return -1; /* only stereo or mono =) */
0147f198
FR
143 switch(avctx->codec->id) {
144 case CODEC_ID_ADPCM_IMA_QT:
8dbcc9f2 145 av_log(avctx, AV_LOG_ERROR, "ADPCM: codec adpcm_ima_qt unsupported for encoding !\n");
889c5224
FR
146 avctx->frame_size = 64; /* XXX: can multiple of avctx->channels * 64 (left and right blocks are interleaved) */
147 return -1;
0147f198
FR
148 break;
149 case CODEC_ID_ADPCM_IMA_WAV:
889c5224
FR
150 avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */
151 /* and we have 4 bytes per channel overhead */
152 avctx->block_align = BLKSIZE;
153 /* seems frame_size isn't taken into account... have to buffer the samples :-( */
154 break;
155 case CODEC_ID_ADPCM_MS:
8dbcc9f2 156 av_log(avctx, AV_LOG_ERROR, "ADPCM: codec adpcm_ms unsupported for encoding !\n");
889c5224 157 return -1;
0147f198
FR
158 break;
159 default:
889c5224 160 return -1;
0147f198
FR
161 break;
162 }
492cd3a9
MN
163
164 avctx->coded_frame= avcodec_alloc_frame();
165 avctx->coded_frame->key_frame= 1;
166
0147f198
FR
167 return 0;
168}
169
170static int adpcm_encode_close(AVCodecContext *avctx)
171{
492cd3a9
MN
172 av_freep(&avctx->coded_frame);
173
0147f198
FR
174 return 0;
175}
176
889c5224
FR
177
178static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample)
179{
180 int step_index;
181 unsigned char nibble;
182
183 int sign = 0; /* sign bit of the nibble (MSB) */
184 int delta, predicted_delta;
185
186 delta = sample - c->prev_sample;
187
188 if (delta < 0) {
189 sign = 1;
190 delta = -delta;
191 }
192
193 step_index = c->step_index;
194
195 /* nibble = 4 * delta / step_table[step_index]; */
196 nibble = (delta << 2) / step_table[step_index];
197
198 if (nibble > 7)
199 nibble = 7;
200
201 step_index += index_table[nibble];
202 if (step_index < 0)
203 step_index = 0;
204 if (step_index > 88)
205 step_index = 88;
206
207 /* what the decoder will find */
208 predicted_delta = ((step_table[step_index] * nibble) / 4) + (step_table[step_index] / 8);
209
210 if (sign)
211 c->prev_sample -= predicted_delta;
212 else
213 c->prev_sample += predicted_delta;
214
215 CLAMP_TO_SHORT(c->prev_sample);
216
217
218 nibble += sign << 3; /* sign * 8 */
219
220 /* save back */
221 c->step_index = step_index;
222
223 return nibble;
224}
225
0147f198
FR
226static int adpcm_encode_frame(AVCodecContext *avctx,
227 unsigned char *frame, int buf_size, void *data)
228{
889c5224 229 int n;
0147f198
FR
230 short *samples;
231 unsigned char *dst;
889c5224
FR
232 ADPCMContext *c = avctx->priv_data;
233
234 dst = frame;
235 samples = (short *)data;
236/* n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */
0147f198
FR
237
238 switch(avctx->codec->id) {
889c5224
FR
239 case CODEC_ID_ADPCM_IMA_QT: /* XXX: can't test until we get .mov writer */
240 break;
241 case CODEC_ID_ADPCM_IMA_WAV:
242 n = avctx->frame_size / 8;
243 c->status[0].prev_sample = (signed short)samples[0]; /* XXX */
244/* c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */
245 *dst++ = (c->status[0].prev_sample) & 0xFF; /* little endian */
246 *dst++ = (c->status[0].prev_sample >> 8) & 0xFF;
247 *dst++ = (unsigned char)c->status[0].step_index;
248 *dst++ = 0; /* unknown */
249 samples++;
250 if (avctx->channels == 2) {
1ffb0091 251 c->status[1].prev_sample = (signed short)samples[1];
889c5224
FR
252/* c->status[1].step_index = 0; */
253 *dst++ = (c->status[1].prev_sample) & 0xFF;
254 *dst++ = (c->status[1].prev_sample >> 8) & 0xFF;
255 *dst++ = (unsigned char)c->status[1].step_index;
256 *dst++ = 0;
257 samples++;
258 }
259
260 /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */
261 for (; n>0; n--) {
262 *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]) & 0x0F;
263 *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4) & 0xF0;
264 dst++;
265 *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]) & 0x0F;
266 *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4) & 0xF0;
267 dst++;
268 *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]) & 0x0F;
269 *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4) & 0xF0;
270 dst++;
271 *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]) & 0x0F;
272 *dst |= (adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4) & 0xF0;
273 dst++;
274 /* right channel */
275 if (avctx->channels == 2) {
276 *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]);
277 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4;
278 dst++;
279 *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]);
280 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4;
281 dst++;
282 *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]);
283 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;
284 dst++;
285 *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]);
286 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
287 dst++;
288 }
289 samples += 8 * avctx->channels;
290 }
291 break;
0147f198
FR
292 default:
293 return -1;
294 }
0147f198
FR
295 return dst - frame;
296}
764ef400 297#endif //CONFIG_ENCODERS
0147f198
FR
298
299static int adpcm_decode_init(AVCodecContext * avctx)
300{
301 ADPCMContext *c = avctx->priv_data;
302
303 c->channel = 0;
304 c->status[0].predictor = c->status[1].predictor = 0;
305 c->status[0].step_index = c->status[1].step_index = 0;
306 c->status[0].step = c->status[1].step = 0;
307
308 switch(avctx->codec->id) {
309 default:
310 break;
311 }
312 return 0;
313}
314
d94728c3 315static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
0147f198
FR
316{
317 int step_index;
318 int predictor;
319 int sign, delta, diff, step;
320
135ee03a 321 step = step_table[c->step_index];
0147f198
FR
322 step_index = c->step_index + index_table[(unsigned)nibble];
323 if (step_index < 0) step_index = 0;
135ee03a 324 else if (step_index > 88) step_index = 88;
0147f198 325
0147f198
FR
326 sign = nibble & 8;
327 delta = nibble & 7;
9937e686
MM
328 /* perform direct multiplication instead of series of jumps proposed by
329 * the reference ADPCM implementation since modern CPUs can do the mults
330 * quickly enough */
d94728c3 331 diff = ((2 * delta + 1) * step) >> shift;
4b465299
MN
332 predictor = c->predictor;
333 if (sign) predictor -= diff;
334 else predictor += diff;
335
336 CLAMP_TO_SHORT(predictor);
337 c->predictor = predictor;
338 c->step_index = step_index;
339
340 return (short)predictor;
341}
342
0147f198
FR
343static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
344{
345 int predictor;
346
347 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
348 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
349 CLAMP_TO_SHORT(predictor);
350
351 c->sample2 = c->sample1;
352 c->sample1 = predictor;
353 c->idelta = (AdaptationTable[(int)nibble] * c->idelta) / 256;
354 if (c->idelta < 16) c->idelta = 16;
355
356 return (short)predictor;
357}
358
fc384777
MM
359static void xa_decode(short *out, const unsigned char *in,
360 ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
361{
362 int i, j;
363 int shift,filter,f0,f1;
364 int s_1,s_2;
365 int d,s,t;
366
367 for(i=0;i<4;i++) {
368
369 shift = 12 - (in[4+i*2] & 15);
370 filter = in[4+i*2] >> 4;
371 f0 = xa_adpcm_table[filter][0];
372 f1 = xa_adpcm_table[filter][1];
373
374 s_1 = left->sample1;
375 s_2 = left->sample2;
376
377 for(j=0;j<28;j++) {
378 d = in[16+i+j*4];
379
380 t = (signed char)(d<<4)>>4;
381 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
382 CLAMP_TO_SHORT(s);
383 *out = s;
384 out += inc;
385 s_2 = s_1;
386 s_1 = s;
387 }
388
389 if (inc==2) { /* stereo */
390 left->sample1 = s_1;
391 left->sample2 = s_2;
392 s_1 = right->sample1;
393 s_2 = right->sample2;
394 out = out + 1 - 28*2;
395 }
396
397 shift = 12 - (in[5+i*2] & 15);
398 filter = in[5+i*2] >> 4;
399
400 f0 = xa_adpcm_table[filter][0];
401 f1 = xa_adpcm_table[filter][1];
402
403 for(j=0;j<28;j++) {
404 d = in[16+i+j*4];
405
406 t = (signed char)d >> 4;
407 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
408 CLAMP_TO_SHORT(s);
409 *out = s;
410 out += inc;
411 s_2 = s_1;
412 s_1 = s;
413 }
414
415 if (inc==2) { /* stereo */
416 right->sample1 = s_1;
417 right->sample2 = s_2;
418 out -= 1;
419 } else {
420 left->sample1 = s_1;
421 left->sample2 = s_2;
422 }
423 }
424}
425
426
9937e686
MM
427/* DK3 ADPCM support macro */
428#define DK3_GET_NEXT_NIBBLE() \
429 if (decode_top_nibble_next) \
430 { \
431 nibble = (last_byte >> 4) & 0x0F; \
432 decode_top_nibble_next = 0; \
433 } \
434 else \
435 { \
436 last_byte = *src++; \
437 if (src >= buf + buf_size) break; \
438 nibble = last_byte & 0x0F; \
439 decode_top_nibble_next = 1; \
440 }
441
0147f198
FR
442static int adpcm_decode_frame(AVCodecContext *avctx,
443 void *data, int *data_size,
0c1a9eda 444 uint8_t *buf, int buf_size)
0147f198
FR
445{
446 ADPCMContext *c = avctx->priv_data;
447 ADPCMChannelStatus *cs;
4b465299 448 int n, m, channel, i;
0147f198
FR
449 int block_predictor[2];
450 short *samples;
0c1a9eda 451 uint8_t *src;
0147f198
FR
452 int st; /* stereo */
453
9937e686
MM
454 /* DK3 ADPCM accounting variables */
455 unsigned char last_byte = 0;
456 unsigned char nibble;
457 int decode_top_nibble_next = 0;
458 int diff_channel;
459
7d8379f2
MM
460 /* EA ADPCM state variables */
461 uint32_t samples_in_chunk;
462 int32_t previous_left_sample, previous_right_sample;
463 int32_t current_left_sample, current_right_sample;
464 int32_t next_left_sample, next_right_sample;
465 int32_t coeff1l, coeff2l, coeff1r, coeff2r;
466 uint8_t shift_left, shift_right;
467 int count1, count2;
468
df72754d
MM
469 if (!buf_size)
470 return 0;
471
0147f198
FR
472 samples = data;
473 src = buf;
474
0147f198
FR
475 st = avctx->channels == 2;
476
477 switch(avctx->codec->id) {
478 case CODEC_ID_ADPCM_IMA_QT:
479 n = (buf_size - 2);/* >> 2*avctx->channels;*/
480 channel = c->channel;
481 cs = &(c->status[channel]);
482 /* (pppppp) (piiiiiii) */
483
484 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
485 cs->predictor = (*src++) << 8;
486 cs->predictor |= (*src & 0x80);
487 cs->predictor &= 0xFF80;
488
489 /* sign extension */
490 if(cs->predictor & 0x8000)
491 cs->predictor -= 0x10000;
492
493 CLAMP_TO_SHORT(cs->predictor);
494
495 cs->step_index = (*src++) & 0x7F;
496
9b879566 497 if (cs->step_index > 88) av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
0147f198
FR
498 if (cs->step_index > 88) cs->step_index = 88;
499
500 cs->step = step_table[cs->step_index];
501
502 if (st && channel)
503 samples++;
504
505 for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
d94728c3 506 *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3);
0147f198 507 samples += avctx->channels;
d94728c3 508 *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F, 3);
0147f198
FR
509 samples += avctx->channels;
510 src ++;
511 }
512
513 if(st) { /* handle stereo interlacing */
514 c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
ac3d5cac 515 if(channel == 1) { /* wait for the other packet before outputing anything */
0147f198
FR
516 *data_size = 0;
517 return src - buf;
518 }
519 }
520 break;
521 case CODEC_ID_ADPCM_IMA_WAV:
ca1d62f4
AY
522 if (avctx->block_align != 0 && buf_size > avctx->block_align)
523 buf_size = avctx->block_align;
524
d94728c3
MN
525 for(i=0; i<avctx->channels; i++){
526 cs = &(c->status[i]);
527 cs->predictor = *src++;
528 cs->predictor |= (*src++) << 8;
0147f198
FR
529 if(cs->predictor & 0x8000)
530 cs->predictor -= 0x10000;
531 CLAMP_TO_SHORT(cs->predictor);
532
d94728c3 533 // XXX: is this correct ??: *samples++ = cs->predictor;
889c5224 534
d94728c3 535 cs->step_index = *src++;
0147f198
FR
536 if (cs->step_index < 0) cs->step_index = 0;
537 if (cs->step_index > 88) cs->step_index = 88;
d94728c3 538 if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null !!\n"); /* unused */
0147f198 539 }
0147f198 540
6b9b85c1 541 for(m=4; src < (buf + buf_size);) {
d94728c3 542 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F, 3);
0147f198 543 if (st)
d94728c3
MN
544 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F, 3);
545 *samples++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F, 3);
6b9b85c1 546 if (st) {
d94728c3 547 *samples++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F, 3);
6b9b85c1
ZK
548 if (!--m) {
549 m=4;
550 src+=4;
551 }
552 }
553 src++;
135ee03a 554 }
0147f198 555 break;
4b465299
MN
556 case CODEC_ID_ADPCM_4XM:
557 cs = &(c->status[0]);
558 c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
559 if(st){
560 c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
561 }
562 c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
563 if(st){
564 c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
565 }
ac3d5cac
MM
566 if (cs->step_index < 0) cs->step_index = 0;
567 if (cs->step_index > 88) cs->step_index = 88;
4b465299
MN
568
569 m= (buf_size - (src - buf))>>st;
4b465299 570 for(i=0; i<m; i++) {
d94728c3 571 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);
4b465299 572 if (st)
d94728c3
MN
573 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);
574 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);
4b465299 575 if (st)
d94728c3 576 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);
4b465299
MN
577 }
578
579 src += m<<st;
580
581 break;
0147f198 582 case CODEC_ID_ADPCM_MS:
ca1d62f4
AY
583 if (avctx->block_align != 0 && buf_size > avctx->block_align)
584 buf_size = avctx->block_align;
0147f198
FR
585 n = buf_size - 7 * avctx->channels;
586 if (n < 0)
587 return -1;
588 block_predictor[0] = (*src++); /* should be bound */
589 block_predictor[0] = (block_predictor[0] < 0)?(0):((block_predictor[0] > 7)?(7):(block_predictor[0]));
590 block_predictor[1] = 0;
591 if (st)
592 block_predictor[1] = (*src++);
593 block_predictor[1] = (block_predictor[1] < 0)?(0):((block_predictor[1] > 7)?(7):(block_predictor[1]));
594 c->status[0].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
595 if (c->status[0].idelta & 0x08000)
596 c->status[0].idelta -= 0x10000;
597 src+=2;
598 if (st)
599 c->status[1].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
600 if (st && c->status[1].idelta & 0x08000)
601 c->status[1].idelta |= 0xFFFF0000;
602 if (st)
603 src+=2;
604 c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
605 c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
606 c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
607 c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
608
609 c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
610 src+=2;
611 if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
612 if (st) src+=2;
613 c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
614 src+=2;
615 if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
616 if (st) src+=2;
617
618 *samples++ = c->status[0].sample1;
619 if (st) *samples++ = c->status[1].sample1;
620 *samples++ = c->status[0].sample2;
621 if (st) *samples++ = c->status[1].sample2;
622 for(;n>0;n--) {
623 *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
624 *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
625 src ++;
626 }
627 break;
9937e686 628 case CODEC_ID_ADPCM_IMA_DK4:
5c69a4fd
MN
629 if (avctx->block_align != 0 && buf_size > avctx->block_align)
630 buf_size = avctx->block_align;
631
9937e686
MM
632 c->status[0].predictor = (src[0] | (src[1] << 8));
633 c->status[0].step_index = src[2];
634 src += 4;
635 if(c->status[0].predictor & 0x8000)
636 c->status[0].predictor -= 0x10000;
637 *samples++ = c->status[0].predictor;
638 if (st) {
639 c->status[1].predictor = (src[0] | (src[1] << 8));
640 c->status[1].step_index = src[2];
641 src += 4;
642 if(c->status[1].predictor & 0x8000)
643 c->status[1].predictor -= 0x10000;
644 *samples++ = c->status[1].predictor;
645 }
646 while (src < buf + buf_size) {
647
648 /* take care of the top nibble (always left or mono channel) */
649 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 650 (src[0] >> 4) & 0x0F, 3);
9937e686
MM
651
652 /* take care of the bottom nibble, which is right sample for
653 * stereo, or another mono sample */
654 if (st)
655 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
d94728c3 656 src[0] & 0x0F, 3);
9937e686
MM
657 else
658 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 659 src[0] & 0x0F, 3);
9937e686
MM
660
661 src++;
662 }
663 break;
664 case CODEC_ID_ADPCM_IMA_DK3:
5c69a4fd
MN
665 if (avctx->block_align != 0 && buf_size > avctx->block_align)
666 buf_size = avctx->block_align;
667
9937e686
MM
668 c->status[0].predictor = (src[10] | (src[11] << 8));
669 c->status[1].predictor = (src[12] | (src[13] << 8));
670 c->status[0].step_index = src[14];
671 c->status[1].step_index = src[15];
672 /* sign extend the predictors */
673 if(c->status[0].predictor & 0x8000)
674 c->status[0].predictor -= 0x10000;
675 if(c->status[1].predictor & 0x8000)
676 c->status[1].predictor -= 0x10000;
677 src += 16;
678 diff_channel = c->status[1].predictor;
679
680 /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
681 * the buffer is consumed */
682 while (1) {
683
684 /* for this algorithm, c->status[0] is the sum channel and
685 * c->status[1] is the diff channel */
686
687 /* process the first predictor of the sum channel */
688 DK3_GET_NEXT_NIBBLE();
d94728c3 689 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
9937e686
MM
690
691 /* process the diff channel predictor */
692 DK3_GET_NEXT_NIBBLE();
d94728c3 693 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
9937e686
MM
694
695 /* process the first pair of stereo PCM samples */
696 diff_channel = (diff_channel + c->status[1].predictor) / 2;
697 *samples++ = c->status[0].predictor + c->status[1].predictor;
698 *samples++ = c->status[0].predictor - c->status[1].predictor;
699
700 /* process the second predictor of the sum channel */
701 DK3_GET_NEXT_NIBBLE();
d94728c3 702 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
9937e686
MM
703
704 /* process the second pair of stereo PCM samples */
705 diff_channel = (diff_channel + c->status[1].predictor) / 2;
706 *samples++ = c->status[0].predictor + c->status[1].predictor;
707 *samples++ = c->status[0].predictor - c->status[1].predictor;
708 }
709 break;
2fdf638b
MM
710 case CODEC_ID_ADPCM_IMA_WS:
711 /* no per-block initialization; just start decoding the data */
712 while (src < buf + buf_size) {
713
714 if (st) {
715 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 716 (src[0] >> 4) & 0x0F, 3);
2fdf638b 717 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
d94728c3 718 src[0] & 0x0F, 3);
2fdf638b
MM
719 } else {
720 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 721 (src[0] >> 4) & 0x0F, 3);
2fdf638b 722 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 723 src[0] & 0x0F, 3);
2fdf638b
MM
724 }
725
726 src++;
727 }
728 break;
fc384777
MM
729 case CODEC_ID_ADPCM_XA:
730 c->status[0].sample1 = c->status[0].sample2 =
731 c->status[1].sample1 = c->status[1].sample2 = 0;
732 while (buf_size >= 128) {
733 xa_decode(samples, src, &c->status[0], &c->status[1],
734 avctx->channels);
735 src += 128;
736 samples += 28 * 8;
737 buf_size -= 128;
738 }
739 break;
7d8379f2
MM
740 case CODEC_ID_ADPCM_EA:
741 samples_in_chunk = LE_32(src);
742 if (samples_in_chunk >= ((buf_size - 12) * 2)) {
743 src += buf_size;
744 break;
745 }
746 src += 4;
747 current_left_sample = (int16_t)LE_16(src);
748 src += 2;
749 previous_left_sample = (int16_t)LE_16(src);
750 src += 2;
751 current_right_sample = (int16_t)LE_16(src);
752 src += 2;
753 previous_right_sample = (int16_t)LE_16(src);
754 src += 2;
755
756 for (count1 = 0; count1 < samples_in_chunk/28;count1++) {
757 coeff1l = ea_adpcm_table[(*src >> 4) & 0x0F];
758 coeff2l = ea_adpcm_table[((*src >> 4) & 0x0F) + 4];
759 coeff1r = ea_adpcm_table[*src & 0x0F];
760 coeff2r = ea_adpcm_table[(*src & 0x0F) + 4];
761 src++;
762
763 shift_left = ((*src >> 4) & 0x0F) + 8;
764 shift_right = (*src & 0x0F) + 8;
765 src++;
766
767 for (count2 = 0; count2 < 28; count2++) {
768 next_left_sample = (((*src & 0xF0) << 24) >> shift_left);
769 next_right_sample = (((*src & 0x0F) << 28) >> shift_right);
770 src++;
771
772 next_left_sample = (next_left_sample +
773 (current_left_sample * coeff1l) +
774 (previous_left_sample * coeff2l) + 0x80) >> 8;
775 next_right_sample = (next_right_sample +
776 (current_right_sample * coeff1r) +
777 (previous_right_sample * coeff2r) + 0x80) >> 8;
778 CLAMP_TO_SHORT(next_left_sample);
779 CLAMP_TO_SHORT(next_right_sample);
780
781 previous_left_sample = current_left_sample;
782 current_left_sample = next_left_sample;
783 previous_right_sample = current_right_sample;
784 current_right_sample = next_right_sample;
785 *samples++ = (unsigned short)current_left_sample;
786 *samples++ = (unsigned short)current_right_sample;
787 }
788 }
789 break;
790 case CODEC_ID_ADPCM_IMA_SMJPEG:
791 c->status[0].predictor = *src;
792 src += 2;
793 c->status[0].step_index = *src++;
794 src++; /* skip another byte before getting to the meat */
795 while (src < buf + buf_size) {
796 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
797 *src & 0x0F, 3);
798 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
799 (*src >> 4) & 0x0F, 3);
800 src++;
801 }
802 break;
0147f198
FR
803 default:
804 *data_size = 0;
805 return -1;
806 }
0c1a9eda 807 *data_size = (uint8_t *)samples - (uint8_t *)data;
0147f198
FR
808 return src - buf;
809}
810
764ef400
MM
811
812
813#ifdef CONFIG_ENCODERS
814#define ADPCM_ENCODER(id,name) \
0147f198
FR
815AVCodec name ## _encoder = { \
816 #name, \
817 CODEC_TYPE_AUDIO, \
818 id, \
819 sizeof(ADPCMContext), \
820 adpcm_encode_init, \
821 adpcm_encode_frame, \
822 adpcm_encode_close, \
823 NULL, \
764ef400
MM
824};
825#else
826#define ADPCM_ENCODER(id,name)
827#endif
828
829#ifdef CONFIG_DECODERS
830#define ADPCM_DECODER(id,name) \
0147f198
FR
831AVCodec name ## _decoder = { \
832 #name, \
833 CODEC_TYPE_AUDIO, \
834 id, \
835 sizeof(ADPCMContext), \
836 adpcm_decode_init, \
837 NULL, \
838 NULL, \
839 adpcm_decode_frame, \
840};
764ef400
MM
841#else
842#define ADPCM_DECODER(id,name)
843#endif
844
845#define ADPCM_CODEC(id, name) \
846ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)
0147f198
FR
847
848ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
849ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
9937e686
MM
850ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);
851ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);
2fdf638b 852ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);
7d8379f2 853ADPCM_CODEC(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
0147f198 854ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
4b465299 855ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm);
fc384777
MM
856ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa);
857ADPCM_CODEC(CODEC_ID_ADPCM_ADX, adpcm_adx);
7d8379f2 858ADPCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea);
0147f198
FR
859
860#undef ADPCM_CODEC