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