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