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