simplify
[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
d94728c3 302static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)
0147f198
FR
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 */
d94728c3 318 diff = ((2 * delta + 1) * step) >> shift;
4b465299
MN
319 predictor = c->predictor;
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;
326
327 return (short)predictor;
328}
329
0147f198
FR
330static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
331{
332 int predictor;
333
334 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256;
335 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
336 CLAMP_TO_SHORT(predictor);
337
338 c->sample2 = c->sample1;
339 c->sample1 = predictor;
340 c->idelta = (AdaptationTable[(int)nibble] * c->idelta) / 256;
341 if (c->idelta < 16) c->idelta = 16;
342
343 return (short)predictor;
344}
345
fc384777
MM
346static void xa_decode(short *out, const unsigned char *in,
347 ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc)
348{
349 int i, j;
350 int shift,filter,f0,f1;
351 int s_1,s_2;
352 int d,s,t;
353
354 for(i=0;i<4;i++) {
355
356 shift = 12 - (in[4+i*2] & 15);
357 filter = in[4+i*2] >> 4;
358 f0 = xa_adpcm_table[filter][0];
359 f1 = xa_adpcm_table[filter][1];
360
361 s_1 = left->sample1;
362 s_2 = left->sample2;
363
364 for(j=0;j<28;j++) {
365 d = in[16+i+j*4];
366
367 t = (signed char)(d<<4)>>4;
368 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
369 CLAMP_TO_SHORT(s);
370 *out = s;
371 out += inc;
372 s_2 = s_1;
373 s_1 = s;
374 }
375
376 if (inc==2) { /* stereo */
377 left->sample1 = s_1;
378 left->sample2 = s_2;
379 s_1 = right->sample1;
380 s_2 = right->sample2;
381 out = out + 1 - 28*2;
382 }
383
384 shift = 12 - (in[5+i*2] & 15);
385 filter = in[5+i*2] >> 4;
386
387 f0 = xa_adpcm_table[filter][0];
388 f1 = xa_adpcm_table[filter][1];
389
390 for(j=0;j<28;j++) {
391 d = in[16+i+j*4];
392
393 t = (signed char)d >> 4;
394 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);
395 CLAMP_TO_SHORT(s);
396 *out = s;
397 out += inc;
398 s_2 = s_1;
399 s_1 = s;
400 }
401
402 if (inc==2) { /* stereo */
403 right->sample1 = s_1;
404 right->sample2 = s_2;
405 out -= 1;
406 } else {
407 left->sample1 = s_1;
408 left->sample2 = s_2;
409 }
410 }
411}
412
413
9937e686
MM
414/* DK3 ADPCM support macro */
415#define DK3_GET_NEXT_NIBBLE() \
416 if (decode_top_nibble_next) \
417 { \
418 nibble = (last_byte >> 4) & 0x0F; \
419 decode_top_nibble_next = 0; \
420 } \
421 else \
422 { \
423 last_byte = *src++; \
424 if (src >= buf + buf_size) break; \
425 nibble = last_byte & 0x0F; \
426 decode_top_nibble_next = 1; \
427 }
428
0147f198
FR
429static int adpcm_decode_frame(AVCodecContext *avctx,
430 void *data, int *data_size,
0c1a9eda 431 uint8_t *buf, int buf_size)
0147f198
FR
432{
433 ADPCMContext *c = avctx->priv_data;
434 ADPCMChannelStatus *cs;
4b465299 435 int n, m, channel, i;
0147f198
FR
436 int block_predictor[2];
437 short *samples;
0c1a9eda 438 uint8_t *src;
0147f198
FR
439 int st; /* stereo */
440
9937e686
MM
441 /* DK3 ADPCM accounting variables */
442 unsigned char last_byte = 0;
443 unsigned char nibble;
444 int decode_top_nibble_next = 0;
445 int diff_channel;
446
df72754d
MM
447 if (!buf_size)
448 return 0;
449
0147f198
FR
450 samples = data;
451 src = buf;
452
0147f198
FR
453 st = avctx->channels == 2;
454
455 switch(avctx->codec->id) {
456 case CODEC_ID_ADPCM_IMA_QT:
457 n = (buf_size - 2);/* >> 2*avctx->channels;*/
458 channel = c->channel;
459 cs = &(c->status[channel]);
460 /* (pppppp) (piiiiiii) */
461
462 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
463 cs->predictor = (*src++) << 8;
464 cs->predictor |= (*src & 0x80);
465 cs->predictor &= 0xFF80;
466
467 /* sign extension */
468 if(cs->predictor & 0x8000)
469 cs->predictor -= 0x10000;
470
471 CLAMP_TO_SHORT(cs->predictor);
472
473 cs->step_index = (*src++) & 0x7F;
474
9b879566 475 if (cs->step_index > 88) av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index);
0147f198
FR
476 if (cs->step_index > 88) cs->step_index = 88;
477
478 cs->step = step_table[cs->step_index];
479
480 if (st && channel)
481 samples++;
482
483 for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
d94728c3 484 *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3);
0147f198 485 samples += avctx->channels;
d94728c3 486 *samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F, 3);
0147f198
FR
487 samples += avctx->channels;
488 src ++;
489 }
490
491 if(st) { /* handle stereo interlacing */
492 c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
ac3d5cac 493 if(channel == 1) { /* wait for the other packet before outputing anything */
0147f198
FR
494 *data_size = 0;
495 return src - buf;
496 }
497 }
498 break;
499 case CODEC_ID_ADPCM_IMA_WAV:
ca1d62f4
AY
500 if (avctx->block_align != 0 && buf_size > avctx->block_align)
501 buf_size = avctx->block_align;
502
d94728c3
MN
503 for(i=0; i<avctx->channels; i++){
504 cs = &(c->status[i]);
505 cs->predictor = *src++;
506 cs->predictor |= (*src++) << 8;
0147f198
FR
507 if(cs->predictor & 0x8000)
508 cs->predictor -= 0x10000;
509 CLAMP_TO_SHORT(cs->predictor);
510
d94728c3 511 // XXX: is this correct ??: *samples++ = cs->predictor;
889c5224 512
d94728c3 513 cs->step_index = *src++;
0147f198
FR
514 if (cs->step_index < 0) cs->step_index = 0;
515 if (cs->step_index > 88) cs->step_index = 88;
d94728c3 516 if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null !!\n"); /* unused */
0147f198 517 }
0147f198 518
6b9b85c1 519 for(m=4; src < (buf + buf_size);) {
d94728c3 520 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F, 3);
0147f198 521 if (st)
d94728c3
MN
522 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F, 3);
523 *samples++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F, 3);
6b9b85c1 524 if (st) {
d94728c3 525 *samples++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F, 3);
6b9b85c1
ZK
526 if (!--m) {
527 m=4;
528 src+=4;
529 }
530 }
531 src++;
135ee03a 532 }
0147f198 533 break;
4b465299
MN
534 case CODEC_ID_ADPCM_4XM:
535 cs = &(c->status[0]);
536 c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
537 if(st){
538 c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
539 }
540 c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
541 if(st){
542 c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
543 }
ac3d5cac
MM
544 if (cs->step_index < 0) cs->step_index = 0;
545 if (cs->step_index > 88) cs->step_index = 88;
4b465299
MN
546
547 m= (buf_size - (src - buf))>>st;
4b465299 548 for(i=0; i<m; i++) {
d94728c3 549 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);
4b465299 550 if (st)
d94728c3
MN
551 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);
552 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);
4b465299 553 if (st)
d94728c3 554 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);
4b465299
MN
555 }
556
557 src += m<<st;
558
559 break;
0147f198 560 case CODEC_ID_ADPCM_MS:
ca1d62f4
AY
561 if (avctx->block_align != 0 && buf_size > avctx->block_align)
562 buf_size = avctx->block_align;
0147f198
FR
563 n = buf_size - 7 * avctx->channels;
564 if (n < 0)
565 return -1;
566 block_predictor[0] = (*src++); /* should be bound */
567 block_predictor[0] = (block_predictor[0] < 0)?(0):((block_predictor[0] > 7)?(7):(block_predictor[0]));
568 block_predictor[1] = 0;
569 if (st)
570 block_predictor[1] = (*src++);
571 block_predictor[1] = (block_predictor[1] < 0)?(0):((block_predictor[1] > 7)?(7):(block_predictor[1]));
572 c->status[0].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
573 if (c->status[0].idelta & 0x08000)
574 c->status[0].idelta -= 0x10000;
575 src+=2;
576 if (st)
577 c->status[1].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
578 if (st && c->status[1].idelta & 0x08000)
579 c->status[1].idelta |= 0xFFFF0000;
580 if (st)
581 src+=2;
582 c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
583 c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
584 c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
585 c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
586
587 c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
588 src+=2;
589 if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
590 if (st) src+=2;
591 c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
592 src+=2;
593 if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
594 if (st) src+=2;
595
596 *samples++ = c->status[0].sample1;
597 if (st) *samples++ = c->status[1].sample1;
598 *samples++ = c->status[0].sample2;
599 if (st) *samples++ = c->status[1].sample2;
600 for(;n>0;n--) {
601 *samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
602 *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
603 src ++;
604 }
605 break;
9937e686 606 case CODEC_ID_ADPCM_IMA_DK4:
5c69a4fd
MN
607 if (avctx->block_align != 0 && buf_size > avctx->block_align)
608 buf_size = avctx->block_align;
609
9937e686
MM
610 c->status[0].predictor = (src[0] | (src[1] << 8));
611 c->status[0].step_index = src[2];
612 src += 4;
613 if(c->status[0].predictor & 0x8000)
614 c->status[0].predictor -= 0x10000;
615 *samples++ = c->status[0].predictor;
616 if (st) {
617 c->status[1].predictor = (src[0] | (src[1] << 8));
618 c->status[1].step_index = src[2];
619 src += 4;
620 if(c->status[1].predictor & 0x8000)
621 c->status[1].predictor -= 0x10000;
622 *samples++ = c->status[1].predictor;
623 }
624 while (src < buf + buf_size) {
625
626 /* take care of the top nibble (always left or mono channel) */
627 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 628 (src[0] >> 4) & 0x0F, 3);
9937e686
MM
629
630 /* take care of the bottom nibble, which is right sample for
631 * stereo, or another mono sample */
632 if (st)
633 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
d94728c3 634 src[0] & 0x0F, 3);
9937e686
MM
635 else
636 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 637 src[0] & 0x0F, 3);
9937e686
MM
638
639 src++;
640 }
641 break;
642 case CODEC_ID_ADPCM_IMA_DK3:
5c69a4fd
MN
643 if (avctx->block_align != 0 && buf_size > avctx->block_align)
644 buf_size = avctx->block_align;
645
9937e686
MM
646 c->status[0].predictor = (src[10] | (src[11] << 8));
647 c->status[1].predictor = (src[12] | (src[13] << 8));
648 c->status[0].step_index = src[14];
649 c->status[1].step_index = src[15];
650 /* sign extend the predictors */
651 if(c->status[0].predictor & 0x8000)
652 c->status[0].predictor -= 0x10000;
653 if(c->status[1].predictor & 0x8000)
654 c->status[1].predictor -= 0x10000;
655 src += 16;
656 diff_channel = c->status[1].predictor;
657
658 /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
659 * the buffer is consumed */
660 while (1) {
661
662 /* for this algorithm, c->status[0] is the sum channel and
663 * c->status[1] is the diff channel */
664
665 /* process the first predictor of the sum channel */
666 DK3_GET_NEXT_NIBBLE();
d94728c3 667 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
9937e686
MM
668
669 /* process the diff channel predictor */
670 DK3_GET_NEXT_NIBBLE();
d94728c3 671 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
9937e686
MM
672
673 /* process the first pair of stereo PCM samples */
674 diff_channel = (diff_channel + c->status[1].predictor) / 2;
675 *samples++ = c->status[0].predictor + c->status[1].predictor;
676 *samples++ = c->status[0].predictor - c->status[1].predictor;
677
678 /* process the second predictor of the sum channel */
679 DK3_GET_NEXT_NIBBLE();
d94728c3 680 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
9937e686
MM
681
682 /* process the second pair of stereo PCM samples */
683 diff_channel = (diff_channel + c->status[1].predictor) / 2;
684 *samples++ = c->status[0].predictor + c->status[1].predictor;
685 *samples++ = c->status[0].predictor - c->status[1].predictor;
686 }
687 break;
2fdf638b
MM
688 case CODEC_ID_ADPCM_IMA_WS:
689 /* no per-block initialization; just start decoding the data */
690 while (src < buf + buf_size) {
691
692 if (st) {
693 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 694 (src[0] >> 4) & 0x0F, 3);
2fdf638b 695 *samples++ = adpcm_ima_expand_nibble(&c->status[1],
d94728c3 696 src[0] & 0x0F, 3);
2fdf638b
MM
697 } else {
698 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 699 (src[0] >> 4) & 0x0F, 3);
2fdf638b 700 *samples++ = adpcm_ima_expand_nibble(&c->status[0],
d94728c3 701 src[0] & 0x0F, 3);
2fdf638b
MM
702 }
703
704 src++;
705 }
706 break;
fc384777
MM
707 case CODEC_ID_ADPCM_XA:
708 c->status[0].sample1 = c->status[0].sample2 =
709 c->status[1].sample1 = c->status[1].sample2 = 0;
710 while (buf_size >= 128) {
711 xa_decode(samples, src, &c->status[0], &c->status[1],
712 avctx->channels);
713 src += 128;
714 samples += 28 * 8;
715 buf_size -= 128;
716 }
717 break;
0147f198
FR
718 default:
719 *data_size = 0;
720 return -1;
721 }
0c1a9eda 722 *data_size = (uint8_t *)samples - (uint8_t *)data;
0147f198
FR
723 return src - buf;
724}
725
764ef400
MM
726
727
728#ifdef CONFIG_ENCODERS
729#define ADPCM_ENCODER(id,name) \
0147f198
FR
730AVCodec name ## _encoder = { \
731 #name, \
732 CODEC_TYPE_AUDIO, \
733 id, \
734 sizeof(ADPCMContext), \
735 adpcm_encode_init, \
736 adpcm_encode_frame, \
737 adpcm_encode_close, \
738 NULL, \
764ef400
MM
739};
740#else
741#define ADPCM_ENCODER(id,name)
742#endif
743
744#ifdef CONFIG_DECODERS
745#define ADPCM_DECODER(id,name) \
0147f198
FR
746AVCodec name ## _decoder = { \
747 #name, \
748 CODEC_TYPE_AUDIO, \
749 id, \
750 sizeof(ADPCMContext), \
751 adpcm_decode_init, \
752 NULL, \
753 NULL, \
754 adpcm_decode_frame, \
755};
764ef400
MM
756#else
757#define ADPCM_DECODER(id,name)
758#endif
759
760#define ADPCM_CODEC(id, name) \
761ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)
0147f198
FR
762
763ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
764ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
9937e686
MM
765ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3);
766ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4);
2fdf638b 767ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws);
0147f198 768ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
4b465299 769ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm);
fc384777
MM
770ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa);
771ADPCM_CODEC(CODEC_ID_ADPCM_ADX, adpcm_adx);
0147f198
FR
772
773#undef ADPCM_CODEC