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