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