alpha amr tip
[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:
8dbcc9f2 132 av_log(avctx, AV_LOG_ERROR, "ADPCM: codec adpcm_ima_qt unsupported for encoding !\n");
889c5224
FR
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:
8dbcc9f2 143 av_log(avctx, AV_LOG_ERROR, "ADPCM: codec adpcm_ms unsupported for encoding !\n");
889c5224 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
9b879566 499 if (cs->step_index > 88) av_log(avctx, AV_LOG_ERROR, "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
507 for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
508 *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F);
509 samples += avctx->channels;
510 *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F);
511 samples += avctx->channels;
512 src ++;
513 }
514
515 if(st) { /* handle stereo interlacing */
516 c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
ac3d5cac 517 if(channel == 1) { /* wait for the other packet before outputing anything */
0147f198
FR
518 *data_size = 0;
519 return src - buf;
520 }
521 }
522 break;
523 case CODEC_ID_ADPCM_IMA_WAV:
ca1d62f4
AY
524 if (avctx->block_align != 0 && buf_size > avctx->block_align)
525 buf_size = avctx->block_align;
526
135ee03a 527 // XXX: do as per-channel loop
0147f198
FR
528 cs = &(c->status[0]);
529 cs->predictor = (*src++) & 0x0FF;
530 cs->predictor |= ((*src++) << 8) & 0x0FF00;
531 if(cs->predictor & 0x8000)
532 cs->predictor -= 0x10000;
533 CLAMP_TO_SHORT(cs->predictor);
534
135ee03a 535 // XXX: is this correct ??: *samples++ = cs->predictor;
889c5224 536
135ee03a 537 cs->step_index = *src++;
0147f198
FR
538 if (cs->step_index < 0) cs->step_index = 0;
539 if (cs->step_index > 88) cs->step_index = 88;
9b879566 540 if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null !!\n"); /* unused */
889c5224 541
0147f198
FR
542 if (st) {
543 cs = &(c->status[1]);
544 cs->predictor = (*src++) & 0x0FF;
545 cs->predictor |= ((*src++) << 8) & 0x0FF00;
546 if(cs->predictor & 0x8000)
547 cs->predictor -= 0x10000;
548 CLAMP_TO_SHORT(cs->predictor);
549
135ee03a 550 // XXX: is this correct ??: *samples++ = cs->predictor;
889c5224 551
135ee03a 552 cs->step_index = *src++;
0147f198
FR
553 if (cs->step_index < 0) cs->step_index = 0;
554 if (cs->step_index > 88) cs->step_index = 88;
135ee03a 555 src++; /* if != 0 -> out-of-sync */
0147f198 556 }
0147f198 557
6b9b85c1
ZK
558 for(m=4; src < (buf + buf_size);) {
559 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F);
0147f198
FR
560 if (st)
561 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F);
562 *samples++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
6b9b85c1 563 if (st) {
0147f198 564 *samples++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F);
6b9b85c1
ZK
565 if (!--m) {
566 m=4;
567 src+=4;
568 }
569 }
570 src++;
135ee03a 571 }
0147f198 572 break;
4b465299
MN
573 case CODEC_ID_ADPCM_4XM:
574 cs = &(c->status[0]);
575 c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
576 if(st){
577 c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
578 }
579 c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
580 if(st){
581 c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
582 }
ac3d5cac
MM
583 if (cs->step_index < 0) cs->step_index = 0;
584 if (cs->step_index > 88) cs->step_index = 88;
4b465299
MN
585
586 m= (buf_size - (src - buf))>>st;
4b465299
MN
587 for(i=0; i<m; i++) {
588 *samples++ = adpcm_4xa_expand_nibble(&c->status[0], src[i] & 0x0F);
589 if (st)
590 *samples++ = adpcm_4xa_expand_nibble(&c->status[1], src[i+m] & 0x0F);
591 *samples++ = adpcm_4xa_expand_nibble(&c->status[0], src[i] >> 4);
592 if (st)
593 *samples++ = adpcm_4xa_expand_nibble(&c->status[1], src[i+m] >> 4);
594 }
595
596 src += m<<st;
597
598 break;
0147f198 599 case CODEC_ID_ADPCM_MS:
ca1d62f4
AY
600 if (avctx->block_align != 0 && buf_size > avctx->block_align)
601 buf_size = avctx->block_align;
0147f198
FR
602 n = buf_size - 7 * avctx->channels;
603 if (n < 0)
604 return -1;
605 block_predictor[0] = (*src++); /* should be bound */
606 block_predictor[0] = (block_predictor[0] < 0)?(0):((block_predictor[0] > 7)?(7):(block_predictor[0]));
607 block_predictor[1] = 0;
608 if (st)
609 block_predictor[1] = (*src++);
610 block_predictor[1] = (block_predictor[1] < 0)?(0):((block_predictor[1] > 7)?(7):(block_predictor[1]));
611 c->status[0].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
612 if (c->status[0].idelta & 0x08000)
613 c->status[0].idelta -= 0x10000;
614 src+=2;
615 if (st)
616 c->status[1].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
617 if (st && c->status[1].idelta & 0x08000)
618 c->status[1].idelta |= 0xFFFF0000;
619 if (st)
620 src+=2;
621 c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
622 c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
623 c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
624 c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
625
626 c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
627 src+=2;
628 if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
629 if (st) src+=2;
630 c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
631 src+=2;
632 if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
633 if (st) src+=2;
634
635 *samples++ = c->status[0].sample1;
636 if (st) *samples++ = c->status[1].sample1;
637 *samples++ = c->status[0].sample2;
638 if (st) *samples++ = c->status[1].sample2;
639 for(;n>0;n--) {
640 *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
641 *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
642 src ++;
643 }
644 break;
9937e686 645 case CODEC_ID_ADPCM_IMA_DK4:
5c69a4fd
MN
646 if (avctx->block_align != 0 && buf_size > avctx->block_align)
647 buf_size = avctx->block_align;
648
9937e686
MM
649 c->status[0].predictor = (src[0] | (src[1] << 8));
650 c->status[0].step_index = src[2];
651 src += 4;
652 if(c->status[0].predictor & 0x8000)
653 c->status[0].predictor -= 0x10000;
654 *samples++ = c->status[0].predictor;
655 if (st) {
656 c->status[1].predictor = (src[0] | (src[1] << 8));
657 c->status[1].step_index = src[2];
658 src += 4;
659 if(c->status[1].predictor & 0x8000)
660 c->status[1].predictor -= 0x10000;
661 *samples++ = c->status[1].predictor;
662 }
663 while (src < buf + buf_size) {
664
665 /* take care of the top nibble (always left or mono channel) */
666 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
667 (src[0] >> 4) & 0x0F);
668
669 /* take care of the bottom nibble, which is right sample for
670 * stereo, or another mono sample */
671 if (st)
672 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
673 src[0] & 0x0F);
674 else
675 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
676 src[0] & 0x0F);
677
678 src++;
679 }
680 break;
681 case CODEC_ID_ADPCM_IMA_DK3:
5c69a4fd
MN
682 if (avctx->block_align != 0 && buf_size > avctx->block_align)
683 buf_size = avctx->block_align;
684
9937e686
MM
685 c->status[0].predictor = (src[10] | (src[11] << 8));
686 c->status[1].predictor = (src[12] | (src[13] << 8));
687 c->status[0].step_index = src[14];
688 c->status[1].step_index = src[15];
689 /* sign extend the predictors */
690 if(c->status[0].predictor & 0x8000)
691 c->status[0].predictor -= 0x10000;
692 if(c->status[1].predictor & 0x8000)
693 c->status[1].predictor -= 0x10000;
694 src += 16;
695 diff_channel = c->status[1].predictor;
696
697 /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
698 * the buffer is consumed */
699 while (1) {
700
701 /* for this algorithm, c->status[0] is the sum channel and
702 * c->status[1] is the diff channel */
703
704 /* process the first predictor of the sum channel */
705 DK3_GET_NEXT_NIBBLE();
706 adpcm_ima_expand_nibble(&c->status[0], nibble);
707
708 /* process the diff channel predictor */
709 DK3_GET_NEXT_NIBBLE();
710 adpcm_ima_expand_nibble(&c->status[1], nibble);
711
712 /* process the first pair of stereo PCM samples */
713 diff_channel = (diff_channel + c->status[1].predictor) / 2;
714 *samples++ = c->status[0].predictor + c->status[1].predictor;
715 *samples++ = c->status[0].predictor - c->status[1].predictor;
716
717 /* process the second predictor of the sum channel */
718 DK3_GET_NEXT_NIBBLE();
719 adpcm_ima_expand_nibble(&c->status[0], nibble);
720
721 /* process the second pair of stereo PCM samples */
722 diff_channel = (diff_channel + c->status[1].predictor) / 2;
723 *samples++ = c->status[0].predictor + c->status[1].predictor;
724 *samples++ = c->status[0].predictor - c->status[1].predictor;
725 }
726 break;
2fdf638b
MM
727 case CODEC_ID_ADPCM_IMA_WS:
728 /* no per-block initialization; just start decoding the data */
729 while (src < buf + buf_size) {
730
731 if (st) {
732 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
733 (src[0] >> 4) & 0x0F);
734 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
735 src[0] & 0x0F);
736 } else {
737 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
738 (src[0] >> 4) & 0x0F);
739 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
740 src[0] & 0x0F);
741 }
742
743 src++;
744 }
745 break;
fc384777
MM
746 case CODEC_ID_ADPCM_XA:
747 c->status[0].sample1 = c->status[0].sample2 =
748 c->status[1].sample1 = c->status[1].sample2 = 0;
749 while (buf_size >= 128) {
750 xa_decode(samples, src, &c->status[0], &c->status[1],
751 avctx->channels);
752 src += 128;
753 samples += 28 * 8;
754 buf_size -= 128;
755 }
756 break;
0147f198
FR
757 default:
758 *data_size = 0;
759 return -1;
760 }
0c1a9eda 761 *data_size = (uint8_t *)samples - (uint8_t *)data;
0147f198
FR
762 return src - buf;
763}
764
764ef400
MM
765
766
767#ifdef CONFIG_ENCODERS
768#define ADPCM_ENCODER(id,name) \
0147f198
FR
769AVCodec name ## _encoder = { \
770 #name, \
771 CODEC_TYPE_AUDIO, \
772 id, \
773 sizeof(ADPCMContext), \
774 adpcm_encode_init, \
775 adpcm_encode_frame, \
776 adpcm_encode_close, \
777 NULL, \
764ef400
MM
778};
779#else
780#define ADPCM_ENCODER(id,name)
781#endif
782
783#ifdef CONFIG_DECODERS
784#define ADPCM_DECODER(id,name) \
0147f198
FR
785AVCodec name ## _decoder = { \
786 #name, \
787 CODEC_TYPE_AUDIO, \
788 id, \
789 sizeof(ADPCMContext), \
790 adpcm_decode_init, \
791 NULL, \
792 NULL, \
793 adpcm_decode_frame, \
794};
764ef400
MM
795#else
796#define ADPCM_DECODER(id,name)
797#endif
798
799#define ADPCM_CODEC(id, name) \
800ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)
0147f198
FR
801
802ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
803ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
9937e686
MM
804ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);
805ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);
2fdf638b 806ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);
0147f198 807ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
4b465299 808ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm);
fc384777
MM
809ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa);
810ADPCM_CODEC(CODEC_ID_ADPCM_ADX, adpcm_adx);
0147f198
FR
811
812#undef ADPCM_CODEC