Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * Copyright (c) 2001-2003 The FFmpeg Project | |
3 | * | |
4 | * first version by Francois Revol (revol@free.fr) | |
5 | * fringe ADPCM codecs (e.g., DK3, DK4, Westwood) | |
6 | * by Mike Melanson (melanson@pcisys.net) | |
7 | * CD-ROM XA ADPCM codec by BERO | |
8 | * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com) | |
9 | * EA ADPCM R1/R2/R3 decoder by Peter Ross (pross@xvid.org) | |
10 | * EA IMA EACS decoder by Peter Ross (pross@xvid.org) | |
11 | * EA IMA SEAD decoder by Peter Ross (pross@xvid.org) | |
12 | * EA ADPCM XAS decoder by Peter Ross (pross@xvid.org) | |
13 | * MAXIS EA ADPCM decoder by Robert Marston (rmarston@gmail.com) | |
14 | * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl) | |
15 | * | |
16 | * This file is part of FFmpeg. | |
17 | * | |
18 | * FFmpeg is free software; you can redistribute it and/or | |
19 | * modify it under the terms of the GNU Lesser General Public | |
20 | * License as published by the Free Software Foundation; either | |
21 | * version 2.1 of the License, or (at your option) any later version. | |
22 | * | |
23 | * FFmpeg is distributed in the hope that it will be useful, | |
24 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
25 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
26 | * Lesser General Public License for more details. | |
27 | * | |
28 | * You should have received a copy of the GNU Lesser General Public | |
29 | * License along with FFmpeg; if not, write to the Free Software | |
30 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
31 | */ | |
32 | #include "avcodec.h" | |
33 | #include "get_bits.h" | |
34 | #include "bytestream.h" | |
35 | #include "adpcm.h" | |
36 | #include "adpcm_data.h" | |
37 | #include "internal.h" | |
38 | ||
39 | /** | |
40 | * @file | |
41 | * ADPCM decoders | |
42 | * Features and limitations: | |
43 | * | |
44 | * Reference documents: | |
45 | * http://wiki.multimedia.cx/index.php?title=Category:ADPCM_Audio_Codecs | |
46 | * http://www.pcisys.net/~melanson/codecs/simpleaudio.html [dead] | |
47 | * http://www.geocities.com/SiliconValley/8682/aud3.txt [dead] | |
48 | * http://openquicktime.sourceforge.net/ | |
49 | * XAnim sources (xa_codec.c) http://xanim.polter.net/ | |
50 | * http://www.cs.ucla.edu/~leec/mediabench/applications.html [dead] | |
51 | * SoX source code http://sox.sourceforge.net/ | |
52 | * | |
53 | * CD-ROM XA: | |
54 | * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html [dead] | |
55 | * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html [dead] | |
56 | * readstr http://www.geocities.co.jp/Playtown/2004/ | |
57 | */ | |
58 | ||
59 | /* These are for CD-ROM XA ADPCM */ | |
60 | static const int xa_adpcm_table[5][2] = { | |
61 | { 0, 0 }, | |
62 | { 60, 0 }, | |
63 | { 115, -52 }, | |
64 | { 98, -55 }, | |
65 | { 122, -60 } | |
66 | }; | |
67 | ||
68 | static const int ea_adpcm_table[] = { | |
69 | 0, 240, 460, 392, | |
70 | 0, 0, -208, -220, | |
71 | 0, 1, 3, 4, | |
72 | 7, 8, 10, 11, | |
73 | 0, -1, -3, -4 | |
74 | }; | |
75 | ||
76 | // padded to zero where table size is less then 16 | |
77 | static const int swf_index_tables[4][16] = { | |
78 | /*2*/ { -1, 2 }, | |
79 | /*3*/ { -1, -1, 2, 4 }, | |
80 | /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 }, | |
81 | /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 } | |
82 | }; | |
83 | ||
84 | /* end of tables */ | |
85 | ||
86 | typedef struct ADPCMDecodeContext { | |
87 | ADPCMChannelStatus status[6]; | |
88 | int vqa_version; /**< VQA version. Used for ADPCM_IMA_WS */ | |
89 | } ADPCMDecodeContext; | |
90 | ||
91 | static av_cold int adpcm_decode_init(AVCodecContext * avctx) | |
92 | { | |
93 | ADPCMDecodeContext *c = avctx->priv_data; | |
94 | unsigned int min_channels = 1; | |
95 | unsigned int max_channels = 2; | |
96 | ||
97 | switch(avctx->codec->id) { | |
98 | case AV_CODEC_ID_ADPCM_DTK: | |
99 | case AV_CODEC_ID_ADPCM_EA: | |
100 | min_channels = 2; | |
101 | break; | |
102 | case AV_CODEC_ID_ADPCM_AFC: | |
103 | case AV_CODEC_ID_ADPCM_EA_R1: | |
104 | case AV_CODEC_ID_ADPCM_EA_R2: | |
105 | case AV_CODEC_ID_ADPCM_EA_R3: | |
106 | case AV_CODEC_ID_ADPCM_EA_XAS: | |
107 | case AV_CODEC_ID_ADPCM_THP: | |
108 | max_channels = 6; | |
109 | break; | |
110 | } | |
111 | if (avctx->channels < min_channels || avctx->channels > max_channels) { | |
112 | av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n"); | |
113 | return AVERROR(EINVAL); | |
114 | } | |
115 | ||
116 | switch(avctx->codec->id) { | |
117 | case AV_CODEC_ID_ADPCM_CT: | |
118 | c->status[0].step = c->status[1].step = 511; | |
119 | break; | |
120 | case AV_CODEC_ID_ADPCM_IMA_WAV: | |
121 | if (avctx->bits_per_coded_sample < 2 || avctx->bits_per_coded_sample > 5) | |
122 | return AVERROR_INVALIDDATA; | |
123 | break; | |
124 | case AV_CODEC_ID_ADPCM_IMA_APC: | |
125 | if (avctx->extradata && avctx->extradata_size >= 8) { | |
126 | c->status[0].predictor = AV_RL32(avctx->extradata); | |
127 | c->status[1].predictor = AV_RL32(avctx->extradata + 4); | |
128 | } | |
129 | break; | |
130 | case AV_CODEC_ID_ADPCM_IMA_WS: | |
131 | if (avctx->extradata && avctx->extradata_size >= 2) | |
132 | c->vqa_version = AV_RL16(avctx->extradata); | |
133 | break; | |
134 | default: | |
135 | break; | |
136 | } | |
137 | ||
138 | switch(avctx->codec->id) { | |
139 | case AV_CODEC_ID_ADPCM_IMA_QT: | |
140 | case AV_CODEC_ID_ADPCM_IMA_WAV: | |
141 | case AV_CODEC_ID_ADPCM_4XM: | |
142 | case AV_CODEC_ID_ADPCM_XA: | |
143 | case AV_CODEC_ID_ADPCM_EA_R1: | |
144 | case AV_CODEC_ID_ADPCM_EA_R2: | |
145 | case AV_CODEC_ID_ADPCM_EA_R3: | |
146 | case AV_CODEC_ID_ADPCM_EA_XAS: | |
147 | case AV_CODEC_ID_ADPCM_THP: | |
148 | case AV_CODEC_ID_ADPCM_AFC: | |
149 | case AV_CODEC_ID_ADPCM_DTK: | |
150 | avctx->sample_fmt = AV_SAMPLE_FMT_S16P; | |
151 | break; | |
152 | case AV_CODEC_ID_ADPCM_IMA_WS: | |
153 | avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P : | |
154 | AV_SAMPLE_FMT_S16; | |
155 | break; | |
156 | default: | |
157 | avctx->sample_fmt = AV_SAMPLE_FMT_S16; | |
158 | } | |
159 | ||
160 | return 0; | |
161 | } | |
162 | ||
163 | static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift) | |
164 | { | |
165 | int step_index; | |
166 | int predictor; | |
167 | int sign, delta, diff, step; | |
168 | ||
169 | step = ff_adpcm_step_table[c->step_index]; | |
170 | step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble]; | |
171 | step_index = av_clip(step_index, 0, 88); | |
172 | ||
173 | sign = nibble & 8; | |
174 | delta = nibble & 7; | |
175 | /* perform direct multiplication instead of series of jumps proposed by | |
176 | * the reference ADPCM implementation since modern CPUs can do the mults | |
177 | * quickly enough */ | |
178 | diff = ((2 * delta + 1) * step) >> shift; | |
179 | predictor = c->predictor; | |
180 | if (sign) predictor -= diff; | |
181 | else predictor += diff; | |
182 | ||
183 | c->predictor = av_clip_int16(predictor); | |
184 | c->step_index = step_index; | |
185 | ||
186 | return (short)c->predictor; | |
187 | } | |
188 | ||
189 | static inline int16_t adpcm_ima_wav_expand_nibble(ADPCMChannelStatus *c, GetBitContext *gb, int bps) | |
190 | { | |
191 | int nibble, step_index, predictor, sign, delta, diff, step, shift; | |
192 | ||
193 | shift = bps - 1; | |
194 | nibble = get_bits_le(gb, bps), | |
195 | step = ff_adpcm_step_table[c->step_index]; | |
196 | step_index = c->step_index + ff_adpcm_index_tables[bps - 2][nibble]; | |
197 | step_index = av_clip(step_index, 0, 88); | |
198 | ||
199 | sign = nibble & (1 << shift); | |
200 | delta = nibble & ((1 << shift) - 1); | |
201 | diff = ((2 * delta + 1) * step) >> shift; | |
202 | predictor = c->predictor; | |
203 | if (sign) predictor -= diff; | |
204 | else predictor += diff; | |
205 | ||
206 | c->predictor = av_clip_int16(predictor); | |
207 | c->step_index = step_index; | |
208 | ||
209 | return (int16_t)c->predictor; | |
210 | } | |
211 | ||
212 | static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift) | |
213 | { | |
214 | int step_index; | |
215 | int predictor; | |
216 | int diff, step; | |
217 | ||
218 | step = ff_adpcm_step_table[c->step_index]; | |
219 | step_index = c->step_index + ff_adpcm_index_table[nibble]; | |
220 | step_index = av_clip(step_index, 0, 88); | |
221 | ||
222 | diff = step >> 3; | |
223 | if (nibble & 4) diff += step; | |
224 | if (nibble & 2) diff += step >> 1; | |
225 | if (nibble & 1) diff += step >> 2; | |
226 | ||
227 | if (nibble & 8) | |
228 | predictor = c->predictor - diff; | |
229 | else | |
230 | predictor = c->predictor + diff; | |
231 | ||
232 | c->predictor = av_clip_int16(predictor); | |
233 | c->step_index = step_index; | |
234 | ||
235 | return c->predictor; | |
236 | } | |
237 | ||
238 | static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble) | |
239 | { | |
240 | int predictor; | |
241 | ||
242 | predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64; | |
243 | predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta; | |
244 | ||
245 | c->sample2 = c->sample1; | |
246 | c->sample1 = av_clip_int16(predictor); | |
247 | c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8; | |
248 | if (c->idelta < 16) c->idelta = 16; | |
249 | ||
250 | return c->sample1; | |
251 | } | |
252 | ||
253 | static inline short adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble) | |
254 | { | |
255 | int step_index, predictor, sign, delta, diff, step; | |
256 | ||
257 | step = ff_adpcm_oki_step_table[c->step_index]; | |
258 | step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble]; | |
259 | step_index = av_clip(step_index, 0, 48); | |
260 | ||
261 | sign = nibble & 8; | |
262 | delta = nibble & 7; | |
263 | diff = ((2 * delta + 1) * step) >> 3; | |
264 | predictor = c->predictor; | |
265 | if (sign) predictor -= diff; | |
266 | else predictor += diff; | |
267 | ||
268 | c->predictor = av_clip(predictor, -2048, 2047); | |
269 | c->step_index = step_index; | |
270 | ||
271 | return c->predictor << 4; | |
272 | } | |
273 | ||
274 | static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble) | |
275 | { | |
276 | int sign, delta, diff; | |
277 | int new_step; | |
278 | ||
279 | sign = nibble & 8; | |
280 | delta = nibble & 7; | |
281 | /* perform direct multiplication instead of series of jumps proposed by | |
282 | * the reference ADPCM implementation since modern CPUs can do the mults | |
283 | * quickly enough */ | |
284 | diff = ((2 * delta + 1) * c->step) >> 3; | |
285 | /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */ | |
286 | c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff); | |
287 | c->predictor = av_clip_int16(c->predictor); | |
288 | /* calculate new step and clamp it to range 511..32767 */ | |
289 | new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8; | |
290 | c->step = av_clip(new_step, 511, 32767); | |
291 | ||
292 | return (short)c->predictor; | |
293 | } | |
294 | ||
295 | static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift) | |
296 | { | |
297 | int sign, delta, diff; | |
298 | ||
299 | sign = nibble & (1<<(size-1)); | |
300 | delta = nibble & ((1<<(size-1))-1); | |
301 | diff = delta << (7 + c->step + shift); | |
302 | ||
303 | /* clamp result */ | |
304 | c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256); | |
305 | ||
306 | /* calculate new step */ | |
307 | if (delta >= (2*size - 3) && c->step < 3) | |
308 | c->step++; | |
309 | else if (delta == 0 && c->step > 0) | |
310 | c->step--; | |
311 | ||
312 | return (short) c->predictor; | |
313 | } | |
314 | ||
315 | static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble) | |
316 | { | |
317 | if(!c->step) { | |
318 | c->predictor = 0; | |
319 | c->step = 127; | |
320 | } | |
321 | ||
322 | c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8; | |
323 | c->predictor = av_clip_int16(c->predictor); | |
324 | c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8; | |
325 | c->step = av_clip(c->step, 127, 24567); | |
326 | return c->predictor; | |
327 | } | |
328 | ||
329 | static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1, | |
330 | const uint8_t *in, ADPCMChannelStatus *left, | |
331 | ADPCMChannelStatus *right, int channels, int sample_offset) | |
332 | { | |
333 | int i, j; | |
334 | int shift,filter,f0,f1; | |
335 | int s_1,s_2; | |
336 | int d,s,t; | |
337 | ||
338 | out0 += sample_offset; | |
339 | if (channels == 1) | |
340 | out1 = out0 + 28; | |
341 | else | |
342 | out1 += sample_offset; | |
343 | ||
344 | for(i=0;i<4;i++) { | |
345 | shift = 12 - (in[4+i*2] & 15); | |
346 | filter = in[4+i*2] >> 4; | |
347 | if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) { | |
348 | avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter); | |
349 | filter=0; | |
350 | } | |
351 | f0 = xa_adpcm_table[filter][0]; | |
352 | f1 = xa_adpcm_table[filter][1]; | |
353 | ||
354 | s_1 = left->sample1; | |
355 | s_2 = left->sample2; | |
356 | ||
357 | for(j=0;j<28;j++) { | |
358 | d = in[16+i+j*4]; | |
359 | ||
360 | t = sign_extend(d, 4); | |
361 | s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6); | |
362 | s_2 = s_1; | |
363 | s_1 = av_clip_int16(s); | |
364 | out0[j] = s_1; | |
365 | } | |
366 | ||
367 | if (channels == 2) { | |
368 | left->sample1 = s_1; | |
369 | left->sample2 = s_2; | |
370 | s_1 = right->sample1; | |
371 | s_2 = right->sample2; | |
372 | } | |
373 | ||
374 | shift = 12 - (in[5+i*2] & 15); | |
375 | filter = in[5+i*2] >> 4; | |
376 | if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) { | |
377 | avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter); | |
378 | filter=0; | |
379 | } | |
380 | ||
381 | f0 = xa_adpcm_table[filter][0]; | |
382 | f1 = xa_adpcm_table[filter][1]; | |
383 | ||
384 | for(j=0;j<28;j++) { | |
385 | d = in[16+i+j*4]; | |
386 | ||
387 | t = sign_extend(d >> 4, 4); | |
388 | s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6); | |
389 | s_2 = s_1; | |
390 | s_1 = av_clip_int16(s); | |
391 | out1[j] = s_1; | |
392 | } | |
393 | ||
394 | if (channels == 2) { | |
395 | right->sample1 = s_1; | |
396 | right->sample2 = s_2; | |
397 | } else { | |
398 | left->sample1 = s_1; | |
399 | left->sample2 = s_2; | |
400 | } | |
401 | ||
402 | out0 += 28 * (3 - channels); | |
403 | out1 += 28 * (3 - channels); | |
404 | } | |
405 | ||
406 | return 0; | |
407 | } | |
408 | ||
409 | static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples) | |
410 | { | |
411 | ADPCMDecodeContext *c = avctx->priv_data; | |
412 | GetBitContext gb; | |
413 | const int *table; | |
414 | int k0, signmask, nb_bits, count; | |
415 | int size = buf_size*8; | |
416 | int i; | |
417 | ||
418 | init_get_bits(&gb, buf, size); | |
419 | ||
420 | //read bits & initial values | |
421 | nb_bits = get_bits(&gb, 2)+2; | |
422 | table = swf_index_tables[nb_bits-2]; | |
423 | k0 = 1 << (nb_bits-2); | |
424 | signmask = 1 << (nb_bits-1); | |
425 | ||
426 | while (get_bits_count(&gb) <= size - 22*avctx->channels) { | |
427 | for (i = 0; i < avctx->channels; i++) { | |
428 | *samples++ = c->status[i].predictor = get_sbits(&gb, 16); | |
429 | c->status[i].step_index = get_bits(&gb, 6); | |
430 | } | |
431 | ||
432 | for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) { | |
433 | int i; | |
434 | ||
435 | for (i = 0; i < avctx->channels; i++) { | |
436 | // similar to IMA adpcm | |
437 | int delta = get_bits(&gb, nb_bits); | |
438 | int step = ff_adpcm_step_table[c->status[i].step_index]; | |
439 | long vpdiff = 0; // vpdiff = (delta+0.5)*step/4 | |
440 | int k = k0; | |
441 | ||
442 | do { | |
443 | if (delta & k) | |
444 | vpdiff += step; | |
445 | step >>= 1; | |
446 | k >>= 1; | |
447 | } while(k); | |
448 | vpdiff += step; | |
449 | ||
450 | if (delta & signmask) | |
451 | c->status[i].predictor -= vpdiff; | |
452 | else | |
453 | c->status[i].predictor += vpdiff; | |
454 | ||
455 | c->status[i].step_index += table[delta & (~signmask)]; | |
456 | ||
457 | c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88); | |
458 | c->status[i].predictor = av_clip_int16(c->status[i].predictor); | |
459 | ||
460 | *samples++ = c->status[i].predictor; | |
461 | } | |
462 | } | |
463 | } | |
464 | } | |
465 | ||
466 | /** | |
467 | * Get the number of samples that will be decoded from the packet. | |
468 | * In one case, this is actually the maximum number of samples possible to | |
469 | * decode with the given buf_size. | |
470 | * | |
471 | * @param[out] coded_samples set to the number of samples as coded in the | |
472 | * packet, or 0 if the codec does not encode the | |
473 | * number of samples in each frame. | |
474 | * @param[out] approx_nb_samples set to non-zero if the number of samples | |
475 | * returned is an approximation. | |
476 | */ | |
477 | static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, | |
478 | int buf_size, int *coded_samples, int *approx_nb_samples) | |
479 | { | |
480 | ADPCMDecodeContext *s = avctx->priv_data; | |
481 | int nb_samples = 0; | |
482 | int ch = avctx->channels; | |
483 | int has_coded_samples = 0; | |
484 | int header_size; | |
485 | ||
486 | *coded_samples = 0; | |
487 | *approx_nb_samples = 0; | |
488 | ||
489 | if(ch <= 0) | |
490 | return 0; | |
491 | ||
492 | switch (avctx->codec->id) { | |
493 | /* constant, only check buf_size */ | |
494 | case AV_CODEC_ID_ADPCM_EA_XAS: | |
495 | if (buf_size < 76 * ch) | |
496 | return 0; | |
497 | nb_samples = 128; | |
498 | break; | |
499 | case AV_CODEC_ID_ADPCM_IMA_QT: | |
500 | if (buf_size < 34 * ch) | |
501 | return 0; | |
502 | nb_samples = 64; | |
503 | break; | |
504 | /* simple 4-bit adpcm */ | |
505 | case AV_CODEC_ID_ADPCM_CT: | |
506 | case AV_CODEC_ID_ADPCM_IMA_APC: | |
507 | case AV_CODEC_ID_ADPCM_IMA_EA_SEAD: | |
508 | case AV_CODEC_ID_ADPCM_IMA_OKI: | |
509 | case AV_CODEC_ID_ADPCM_IMA_WS: | |
510 | case AV_CODEC_ID_ADPCM_YAMAHA: | |
511 | nb_samples = buf_size * 2 / ch; | |
512 | break; | |
513 | } | |
514 | if (nb_samples) | |
515 | return nb_samples; | |
516 | ||
517 | /* simple 4-bit adpcm, with header */ | |
518 | header_size = 0; | |
519 | switch (avctx->codec->id) { | |
520 | case AV_CODEC_ID_ADPCM_4XM: | |
521 | case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break; | |
522 | case AV_CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break; | |
523 | case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4 * ch; break; | |
524 | } | |
525 | if (header_size > 0) | |
526 | return (buf_size - header_size) * 2 / ch; | |
527 | ||
528 | /* more complex formats */ | |
529 | switch (avctx->codec->id) { | |
530 | case AV_CODEC_ID_ADPCM_EA: | |
531 | has_coded_samples = 1; | |
532 | *coded_samples = bytestream2_get_le32(gb); | |
533 | *coded_samples -= *coded_samples % 28; | |
534 | nb_samples = (buf_size - 12) / 30 * 28; | |
535 | break; | |
536 | case AV_CODEC_ID_ADPCM_IMA_EA_EACS: | |
537 | has_coded_samples = 1; | |
538 | *coded_samples = bytestream2_get_le32(gb); | |
539 | nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch; | |
540 | break; | |
541 | case AV_CODEC_ID_ADPCM_EA_MAXIS_XA: | |
542 | nb_samples = (buf_size - ch) / ch * 2; | |
543 | break; | |
544 | case AV_CODEC_ID_ADPCM_EA_R1: | |
545 | case AV_CODEC_ID_ADPCM_EA_R2: | |
546 | case AV_CODEC_ID_ADPCM_EA_R3: | |
547 | /* maximum number of samples */ | |
548 | /* has internal offsets and a per-frame switch to signal raw 16-bit */ | |
549 | has_coded_samples = 1; | |
550 | switch (avctx->codec->id) { | |
551 | case AV_CODEC_ID_ADPCM_EA_R1: | |
552 | header_size = 4 + 9 * ch; | |
553 | *coded_samples = bytestream2_get_le32(gb); | |
554 | break; | |
555 | case AV_CODEC_ID_ADPCM_EA_R2: | |
556 | header_size = 4 + 5 * ch; | |
557 | *coded_samples = bytestream2_get_le32(gb); | |
558 | break; | |
559 | case AV_CODEC_ID_ADPCM_EA_R3: | |
560 | header_size = 4 + 5 * ch; | |
561 | *coded_samples = bytestream2_get_be32(gb); | |
562 | break; | |
563 | } | |
564 | *coded_samples -= *coded_samples % 28; | |
565 | nb_samples = (buf_size - header_size) * 2 / ch; | |
566 | nb_samples -= nb_samples % 28; | |
567 | *approx_nb_samples = 1; | |
568 | break; | |
569 | case AV_CODEC_ID_ADPCM_IMA_DK3: | |
570 | if (avctx->block_align > 0) | |
571 | buf_size = FFMIN(buf_size, avctx->block_align); | |
572 | nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch; | |
573 | break; | |
574 | case AV_CODEC_ID_ADPCM_IMA_DK4: | |
575 | if (avctx->block_align > 0) | |
576 | buf_size = FFMIN(buf_size, avctx->block_align); | |
577 | nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch; | |
578 | break; | |
579 | case AV_CODEC_ID_ADPCM_IMA_RAD: | |
580 | if (avctx->block_align > 0) | |
581 | buf_size = FFMIN(buf_size, avctx->block_align); | |
582 | nb_samples = (buf_size - 4 * ch) * 2 / ch; | |
583 | break; | |
584 | case AV_CODEC_ID_ADPCM_IMA_WAV: | |
585 | { | |
586 | int bsize = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2]; | |
587 | int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2]; | |
588 | if (avctx->block_align > 0) | |
589 | buf_size = FFMIN(buf_size, avctx->block_align); | |
590 | nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples; | |
591 | break; | |
592 | } | |
593 | case AV_CODEC_ID_ADPCM_MS: | |
594 | if (avctx->block_align > 0) | |
595 | buf_size = FFMIN(buf_size, avctx->block_align); | |
596 | nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch; | |
597 | break; | |
598 | case AV_CODEC_ID_ADPCM_SBPRO_2: | |
599 | case AV_CODEC_ID_ADPCM_SBPRO_3: | |
600 | case AV_CODEC_ID_ADPCM_SBPRO_4: | |
601 | { | |
602 | int samples_per_byte; | |
603 | switch (avctx->codec->id) { | |
604 | case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break; | |
605 | case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break; | |
606 | case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break; | |
607 | } | |
608 | if (!s->status[0].step_index) { | |
609 | nb_samples++; | |
610 | buf_size -= ch; | |
611 | } | |
612 | nb_samples += buf_size * samples_per_byte / ch; | |
613 | break; | |
614 | } | |
615 | case AV_CODEC_ID_ADPCM_SWF: | |
616 | { | |
617 | int buf_bits = buf_size * 8 - 2; | |
618 | int nbits = (bytestream2_get_byte(gb) >> 6) + 2; | |
619 | int block_hdr_size = 22 * ch; | |
620 | int block_size = block_hdr_size + nbits * ch * 4095; | |
621 | int nblocks = buf_bits / block_size; | |
622 | int bits_left = buf_bits - nblocks * block_size; | |
623 | nb_samples = nblocks * 4096; | |
624 | if (bits_left >= block_hdr_size) | |
625 | nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch); | |
626 | break; | |
627 | } | |
628 | case AV_CODEC_ID_ADPCM_THP: | |
629 | if (avctx->extradata) { | |
630 | nb_samples = buf_size / (8 * ch) * 14; | |
631 | break; | |
632 | } | |
633 | has_coded_samples = 1; | |
634 | bytestream2_skip(gb, 4); // channel size | |
635 | *coded_samples = bytestream2_get_be32(gb); | |
636 | *coded_samples -= *coded_samples % 14; | |
637 | nb_samples = (buf_size - (8 + 36 * ch)) / (8 * ch) * 14; | |
638 | break; | |
639 | case AV_CODEC_ID_ADPCM_AFC: | |
640 | nb_samples = buf_size / (9 * ch) * 16; | |
641 | break; | |
642 | case AV_CODEC_ID_ADPCM_XA: | |
643 | nb_samples = (buf_size / 128) * 224 / ch; | |
644 | break; | |
645 | case AV_CODEC_ID_ADPCM_DTK: | |
646 | nb_samples = buf_size / (16 * ch) * 28; | |
647 | break; | |
648 | } | |
649 | ||
650 | /* validate coded sample count */ | |
651 | if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples)) | |
652 | return AVERROR_INVALIDDATA; | |
653 | ||
654 | return nb_samples; | |
655 | } | |
656 | ||
657 | static int adpcm_decode_frame(AVCodecContext *avctx, void *data, | |
658 | int *got_frame_ptr, AVPacket *avpkt) | |
659 | { | |
660 | AVFrame *frame = data; | |
661 | const uint8_t *buf = avpkt->data; | |
662 | int buf_size = avpkt->size; | |
663 | ADPCMDecodeContext *c = avctx->priv_data; | |
664 | ADPCMChannelStatus *cs; | |
665 | int n, m, channel, i; | |
666 | short *samples; | |
667 | int16_t **samples_p; | |
668 | int st; /* stereo */ | |
669 | int count1, count2; | |
670 | int nb_samples, coded_samples, approx_nb_samples, ret; | |
671 | GetByteContext gb; | |
672 | ||
673 | bytestream2_init(&gb, buf, buf_size); | |
674 | nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples); | |
675 | if (nb_samples <= 0) { | |
676 | av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n"); | |
677 | return AVERROR_INVALIDDATA; | |
678 | } | |
679 | ||
680 | /* get output buffer */ | |
681 | frame->nb_samples = nb_samples; | |
682 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) | |
683 | return ret; | |
684 | samples = (short *)frame->data[0]; | |
685 | samples_p = (int16_t **)frame->extended_data; | |
686 | ||
687 | /* use coded_samples when applicable */ | |
688 | /* it is always <= nb_samples, so the output buffer will be large enough */ | |
689 | if (coded_samples) { | |
690 | if (!approx_nb_samples && coded_samples != nb_samples) | |
691 | av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n"); | |
692 | frame->nb_samples = nb_samples = coded_samples; | |
693 | } | |
694 | ||
695 | st = avctx->channels == 2 ? 1 : 0; | |
696 | ||
697 | switch(avctx->codec->id) { | |
698 | case AV_CODEC_ID_ADPCM_IMA_QT: | |
699 | /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples). | |
700 | Channel data is interleaved per-chunk. */ | |
701 | for (channel = 0; channel < avctx->channels; channel++) { | |
702 | int predictor; | |
703 | int step_index; | |
704 | cs = &(c->status[channel]); | |
705 | /* (pppppp) (piiiiiii) */ | |
706 | ||
707 | /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */ | |
708 | predictor = sign_extend(bytestream2_get_be16u(&gb), 16); | |
709 | step_index = predictor & 0x7F; | |
710 | predictor &= ~0x7F; | |
711 | ||
712 | if (cs->step_index == step_index) { | |
713 | int diff = predictor - cs->predictor; | |
714 | if (diff < 0) | |
715 | diff = - diff; | |
716 | if (diff > 0x7f) | |
717 | goto update; | |
718 | } else { | |
719 | update: | |
720 | cs->step_index = step_index; | |
721 | cs->predictor = predictor; | |
722 | } | |
723 | ||
724 | if (cs->step_index > 88u){ | |
725 | av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n", | |
726 | channel, cs->step_index); | |
727 | return AVERROR_INVALIDDATA; | |
728 | } | |
729 | ||
730 | samples = samples_p[channel]; | |
731 | ||
732 | for (m = 0; m < 64; m += 2) { | |
733 | int byte = bytestream2_get_byteu(&gb); | |
734 | samples[m ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F, 3); | |
735 | samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4 , 3); | |
736 | } | |
737 | } | |
738 | break; | |
739 | case AV_CODEC_ID_ADPCM_IMA_WAV: | |
740 | for(i=0; i<avctx->channels; i++){ | |
741 | cs = &(c->status[i]); | |
742 | cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16); | |
743 | ||
744 | cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16); | |
745 | if (cs->step_index > 88u){ | |
746 | av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n", | |
747 | i, cs->step_index); | |
748 | return AVERROR_INVALIDDATA; | |
749 | } | |
750 | } | |
751 | ||
752 | if (avctx->bits_per_coded_sample != 4) { | |
753 | int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2]; | |
754 | GetBitContext g; | |
755 | ||
756 | init_get_bits8(&g, gb.buffer, bytestream2_get_bytes_left(&gb)); | |
757 | for (n = 0; n < (nb_samples - 1) / samples_per_block; n++) { | |
758 | for (i = 0; i < avctx->channels; i++) { | |
759 | cs = &c->status[i]; | |
760 | samples = &samples_p[i][1 + n * samples_per_block]; | |
761 | for (m = 0; m < samples_per_block; m++) { | |
762 | samples[m] = adpcm_ima_wav_expand_nibble(cs, &g, | |
763 | avctx->bits_per_coded_sample); | |
764 | } | |
765 | } | |
766 | } | |
767 | bytestream2_skip(&gb, avctx->block_align - avctx->channels * 4); | |
768 | } else { | |
769 | for (n = 0; n < (nb_samples - 1) / 8; n++) { | |
770 | for (i = 0; i < avctx->channels; i++) { | |
771 | cs = &c->status[i]; | |
772 | samples = &samples_p[i][1 + n * 8]; | |
773 | for (m = 0; m < 8; m += 2) { | |
774 | int v = bytestream2_get_byteu(&gb); | |
775 | samples[m ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3); | |
776 | samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4 , 3); | |
777 | } | |
778 | } | |
779 | } | |
780 | } | |
781 | break; | |
782 | case AV_CODEC_ID_ADPCM_4XM: | |
783 | for (i = 0; i < avctx->channels; i++) | |
784 | c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); | |
785 | ||
786 | for (i = 0; i < avctx->channels; i++) { | |
787 | c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16); | |
788 | if (c->status[i].step_index > 88u) { | |
789 | av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n", | |
790 | i, c->status[i].step_index); | |
791 | return AVERROR_INVALIDDATA; | |
792 | } | |
793 | } | |
794 | ||
795 | for (i = 0; i < avctx->channels; i++) { | |
796 | samples = (int16_t *)frame->data[i]; | |
797 | cs = &c->status[i]; | |
798 | for (n = nb_samples >> 1; n > 0; n--) { | |
799 | int v = bytestream2_get_byteu(&gb); | |
800 | *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4); | |
801 | *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 4); | |
802 | } | |
803 | } | |
804 | break; | |
805 | case AV_CODEC_ID_ADPCM_MS: | |
806 | { | |
807 | int block_predictor; | |
808 | ||
809 | block_predictor = bytestream2_get_byteu(&gb); | |
810 | if (block_predictor > 6) { | |
811 | av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n", | |
812 | block_predictor); | |
813 | return AVERROR_INVALIDDATA; | |
814 | } | |
815 | c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor]; | |
816 | c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor]; | |
817 | if (st) { | |
818 | block_predictor = bytestream2_get_byteu(&gb); | |
819 | if (block_predictor > 6) { | |
820 | av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n", | |
821 | block_predictor); | |
822 | return AVERROR_INVALIDDATA; | |
823 | } | |
824 | c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor]; | |
825 | c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor]; | |
826 | } | |
827 | c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16); | |
828 | if (st){ | |
829 | c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16); | |
830 | } | |
831 | ||
832 | c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16); | |
833 | if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16); | |
834 | c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16); | |
835 | if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16); | |
836 | ||
837 | *samples++ = c->status[0].sample2; | |
838 | if (st) *samples++ = c->status[1].sample2; | |
839 | *samples++ = c->status[0].sample1; | |
840 | if (st) *samples++ = c->status[1].sample1; | |
841 | for(n = (nb_samples - 2) >> (1 - st); n > 0; n--) { | |
842 | int byte = bytestream2_get_byteu(&gb); | |
843 | *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4 ); | |
844 | *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F); | |
845 | } | |
846 | break; | |
847 | } | |
848 | case AV_CODEC_ID_ADPCM_IMA_DK4: | |
849 | for (channel = 0; channel < avctx->channels; channel++) { | |
850 | cs = &c->status[channel]; | |
851 | cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16); | |
852 | cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16); | |
853 | if (cs->step_index > 88u){ | |
854 | av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n", | |
855 | channel, cs->step_index); | |
856 | return AVERROR_INVALIDDATA; | |
857 | } | |
858 | } | |
859 | for (n = (nb_samples - 1) >> (1 - st); n > 0; n--) { | |
860 | int v = bytestream2_get_byteu(&gb); | |
861 | *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3); | |
862 | *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3); | |
863 | } | |
864 | break; | |
865 | case AV_CODEC_ID_ADPCM_IMA_DK3: | |
866 | { | |
867 | int last_byte = 0; | |
868 | int nibble; | |
869 | int decode_top_nibble_next = 0; | |
870 | int diff_channel; | |
871 | const int16_t *samples_end = samples + avctx->channels * nb_samples; | |
872 | ||
873 | bytestream2_skipu(&gb, 10); | |
874 | c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); | |
875 | c->status[1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); | |
876 | c->status[0].step_index = bytestream2_get_byteu(&gb); | |
877 | c->status[1].step_index = bytestream2_get_byteu(&gb); | |
878 | if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){ | |
879 | av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n", | |
880 | c->status[0].step_index, c->status[1].step_index); | |
881 | return AVERROR_INVALIDDATA; | |
882 | } | |
883 | /* sign extend the predictors */ | |
884 | diff_channel = c->status[1].predictor; | |
885 | ||
886 | /* DK3 ADPCM support macro */ | |
887 | #define DK3_GET_NEXT_NIBBLE() \ | |
888 | if (decode_top_nibble_next) { \ | |
889 | nibble = last_byte >> 4; \ | |
890 | decode_top_nibble_next = 0; \ | |
891 | } else { \ | |
892 | last_byte = bytestream2_get_byteu(&gb); \ | |
893 | nibble = last_byte & 0x0F; \ | |
894 | decode_top_nibble_next = 1; \ | |
895 | } | |
896 | ||
897 | while (samples < samples_end) { | |
898 | ||
899 | /* for this algorithm, c->status[0] is the sum channel and | |
900 | * c->status[1] is the diff channel */ | |
901 | ||
902 | /* process the first predictor of the sum channel */ | |
903 | DK3_GET_NEXT_NIBBLE(); | |
904 | adpcm_ima_expand_nibble(&c->status[0], nibble, 3); | |
905 | ||
906 | /* process the diff channel predictor */ | |
907 | DK3_GET_NEXT_NIBBLE(); | |
908 | adpcm_ima_expand_nibble(&c->status[1], nibble, 3); | |
909 | ||
910 | /* process the first pair of stereo PCM samples */ | |
911 | diff_channel = (diff_channel + c->status[1].predictor) / 2; | |
912 | *samples++ = c->status[0].predictor + c->status[1].predictor; | |
913 | *samples++ = c->status[0].predictor - c->status[1].predictor; | |
914 | ||
915 | /* process the second predictor of the sum channel */ | |
916 | DK3_GET_NEXT_NIBBLE(); | |
917 | adpcm_ima_expand_nibble(&c->status[0], nibble, 3); | |
918 | ||
919 | /* process the second pair of stereo PCM samples */ | |
920 | diff_channel = (diff_channel + c->status[1].predictor) / 2; | |
921 | *samples++ = c->status[0].predictor + c->status[1].predictor; | |
922 | *samples++ = c->status[0].predictor - c->status[1].predictor; | |
923 | } | |
924 | ||
925 | if ((bytestream2_tell(&gb) & 1)) | |
926 | bytestream2_skip(&gb, 1); | |
927 | break; | |
928 | } | |
929 | case AV_CODEC_ID_ADPCM_IMA_ISS: | |
930 | for (channel = 0; channel < avctx->channels; channel++) { | |
931 | cs = &c->status[channel]; | |
932 | cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16); | |
933 | cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16); | |
934 | if (cs->step_index > 88u){ | |
935 | av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n", | |
936 | channel, cs->step_index); | |
937 | return AVERROR_INVALIDDATA; | |
938 | } | |
939 | } | |
940 | ||
941 | for (n = nb_samples >> (1 - st); n > 0; n--) { | |
942 | int v1, v2; | |
943 | int v = bytestream2_get_byteu(&gb); | |
944 | /* nibbles are swapped for mono */ | |
945 | if (st) { | |
946 | v1 = v >> 4; | |
947 | v2 = v & 0x0F; | |
948 | } else { | |
949 | v2 = v >> 4; | |
950 | v1 = v & 0x0F; | |
951 | } | |
952 | *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3); | |
953 | *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3); | |
954 | } | |
955 | break; | |
956 | case AV_CODEC_ID_ADPCM_IMA_APC: | |
957 | while (bytestream2_get_bytes_left(&gb) > 0) { | |
958 | int v = bytestream2_get_byteu(&gb); | |
959 | *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3); | |
960 | *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3); | |
961 | } | |
962 | break; | |
963 | case AV_CODEC_ID_ADPCM_IMA_OKI: | |
964 | while (bytestream2_get_bytes_left(&gb) > 0) { | |
965 | int v = bytestream2_get_byteu(&gb); | |
966 | *samples++ = adpcm_ima_oki_expand_nibble(&c->status[0], v >> 4 ); | |
967 | *samples++ = adpcm_ima_oki_expand_nibble(&c->status[st], v & 0x0F); | |
968 | } | |
969 | break; | |
970 | case AV_CODEC_ID_ADPCM_IMA_RAD: | |
971 | for (channel = 0; channel < avctx->channels; channel++) { | |
972 | cs = &c->status[channel]; | |
973 | cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16); | |
974 | cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16); | |
975 | if (cs->step_index > 88u){ | |
976 | av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n", | |
977 | channel, cs->step_index); | |
978 | return AVERROR_INVALIDDATA; | |
979 | } | |
980 | } | |
981 | for (n = 0; n < nb_samples / 2; n++) { | |
982 | int byte[2]; | |
983 | ||
984 | byte[0] = bytestream2_get_byteu(&gb); | |
985 | if (st) | |
986 | byte[1] = bytestream2_get_byteu(&gb); | |
987 | for(channel = 0; channel < avctx->channels; channel++) { | |
988 | *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] & 0x0F, 3); | |
989 | } | |
990 | for(channel = 0; channel < avctx->channels; channel++) { | |
991 | *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] >> 4 , 3); | |
992 | } | |
993 | } | |
994 | break; | |
995 | case AV_CODEC_ID_ADPCM_IMA_WS: | |
996 | if (c->vqa_version == 3) { | |
997 | for (channel = 0; channel < avctx->channels; channel++) { | |
998 | int16_t *smp = samples_p[channel]; | |
999 | ||
1000 | for (n = nb_samples / 2; n > 0; n--) { | |
1001 | int v = bytestream2_get_byteu(&gb); | |
1002 | *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3); | |
1003 | *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3); | |
1004 | } | |
1005 | } | |
1006 | } else { | |
1007 | for (n = nb_samples / 2; n > 0; n--) { | |
1008 | for (channel = 0; channel < avctx->channels; channel++) { | |
1009 | int v = bytestream2_get_byteu(&gb); | |
1010 | *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3); | |
1011 | samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3); | |
1012 | } | |
1013 | samples += avctx->channels; | |
1014 | } | |
1015 | } | |
1016 | bytestream2_seek(&gb, 0, SEEK_END); | |
1017 | break; | |
1018 | case AV_CODEC_ID_ADPCM_XA: | |
1019 | { | |
1020 | int16_t *out0 = samples_p[0]; | |
1021 | int16_t *out1 = samples_p[1]; | |
1022 | int samples_per_block = 28 * (3 - avctx->channels) * 4; | |
1023 | int sample_offset = 0; | |
1024 | while (bytestream2_get_bytes_left(&gb) >= 128) { | |
1025 | if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb), | |
1026 | &c->status[0], &c->status[1], | |
1027 | avctx->channels, sample_offset)) < 0) | |
1028 | return ret; | |
1029 | bytestream2_skipu(&gb, 128); | |
1030 | sample_offset += samples_per_block; | |
1031 | } | |
1032 | break; | |
1033 | } | |
1034 | case AV_CODEC_ID_ADPCM_IMA_EA_EACS: | |
1035 | for (i=0; i<=st; i++) { | |
1036 | c->status[i].step_index = bytestream2_get_le32u(&gb); | |
1037 | if (c->status[i].step_index > 88u) { | |
1038 | av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n", | |
1039 | i, c->status[i].step_index); | |
1040 | return AVERROR_INVALIDDATA; | |
1041 | } | |
1042 | } | |
1043 | for (i=0; i<=st; i++) | |
1044 | c->status[i].predictor = bytestream2_get_le32u(&gb); | |
1045 | ||
1046 | for (n = nb_samples >> (1 - st); n > 0; n--) { | |
1047 | int byte = bytestream2_get_byteu(&gb); | |
1048 | *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 3); | |
1049 | *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3); | |
1050 | } | |
1051 | break; | |
1052 | case AV_CODEC_ID_ADPCM_IMA_EA_SEAD: | |
1053 | for (n = nb_samples >> (1 - st); n > 0; n--) { | |
1054 | int byte = bytestream2_get_byteu(&gb); | |
1055 | *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6); | |
1056 | *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6); | |
1057 | } | |
1058 | break; | |
1059 | case AV_CODEC_ID_ADPCM_EA: | |
1060 | { | |
1061 | int previous_left_sample, previous_right_sample; | |
1062 | int current_left_sample, current_right_sample; | |
1063 | int next_left_sample, next_right_sample; | |
1064 | int coeff1l, coeff2l, coeff1r, coeff2r; | |
1065 | int shift_left, shift_right; | |
1066 | ||
1067 | /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces, | |
1068 | each coding 28 stereo samples. */ | |
1069 | ||
1070 | if(avctx->channels != 2) | |
1071 | return AVERROR_INVALIDDATA; | |
1072 | ||
1073 | current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16); | |
1074 | previous_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16); | |
1075 | current_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16); | |
1076 | previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16); | |
1077 | ||
1078 | for (count1 = 0; count1 < nb_samples / 28; count1++) { | |
1079 | int byte = bytestream2_get_byteu(&gb); | |
1080 | coeff1l = ea_adpcm_table[ byte >> 4 ]; | |
1081 | coeff2l = ea_adpcm_table[(byte >> 4 ) + 4]; | |
1082 | coeff1r = ea_adpcm_table[ byte & 0x0F]; | |
1083 | coeff2r = ea_adpcm_table[(byte & 0x0F) + 4]; | |
1084 | ||
1085 | byte = bytestream2_get_byteu(&gb); | |
1086 | shift_left = 20 - (byte >> 4); | |
1087 | shift_right = 20 - (byte & 0x0F); | |
1088 | ||
1089 | for (count2 = 0; count2 < 28; count2++) { | |
1090 | byte = bytestream2_get_byteu(&gb); | |
1091 | next_left_sample = sign_extend(byte >> 4, 4) << shift_left; | |
1092 | next_right_sample = sign_extend(byte, 4) << shift_right; | |
1093 | ||
1094 | next_left_sample = (next_left_sample + | |
1095 | (current_left_sample * coeff1l) + | |
1096 | (previous_left_sample * coeff2l) + 0x80) >> 8; | |
1097 | next_right_sample = (next_right_sample + | |
1098 | (current_right_sample * coeff1r) + | |
1099 | (previous_right_sample * coeff2r) + 0x80) >> 8; | |
1100 | ||
1101 | previous_left_sample = current_left_sample; | |
1102 | current_left_sample = av_clip_int16(next_left_sample); | |
1103 | previous_right_sample = current_right_sample; | |
1104 | current_right_sample = av_clip_int16(next_right_sample); | |
1105 | *samples++ = current_left_sample; | |
1106 | *samples++ = current_right_sample; | |
1107 | } | |
1108 | } | |
1109 | ||
1110 | bytestream2_skip(&gb, 2); // Skip terminating 0x0000 | |
1111 | ||
1112 | break; | |
1113 | } | |
1114 | case AV_CODEC_ID_ADPCM_EA_MAXIS_XA: | |
1115 | { | |
1116 | int coeff[2][2], shift[2]; | |
1117 | ||
1118 | for(channel = 0; channel < avctx->channels; channel++) { | |
1119 | int byte = bytestream2_get_byteu(&gb); | |
1120 | for (i=0; i<2; i++) | |
1121 | coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i]; | |
1122 | shift[channel] = 20 - (byte & 0x0F); | |
1123 | } | |
1124 | for (count1 = 0; count1 < nb_samples / 2; count1++) { | |
1125 | int byte[2]; | |
1126 | ||
1127 | byte[0] = bytestream2_get_byteu(&gb); | |
1128 | if (st) byte[1] = bytestream2_get_byteu(&gb); | |
1129 | for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */ | |
1130 | for(channel = 0; channel < avctx->channels; channel++) { | |
1131 | int sample = sign_extend(byte[channel] >> i, 4) << shift[channel]; | |
1132 | sample = (sample + | |
1133 | c->status[channel].sample1 * coeff[channel][0] + | |
1134 | c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8; | |
1135 | c->status[channel].sample2 = c->status[channel].sample1; | |
1136 | c->status[channel].sample1 = av_clip_int16(sample); | |
1137 | *samples++ = c->status[channel].sample1; | |
1138 | } | |
1139 | } | |
1140 | } | |
1141 | bytestream2_seek(&gb, 0, SEEK_END); | |
1142 | break; | |
1143 | } | |
1144 | case AV_CODEC_ID_ADPCM_EA_R1: | |
1145 | case AV_CODEC_ID_ADPCM_EA_R2: | |
1146 | case AV_CODEC_ID_ADPCM_EA_R3: { | |
1147 | /* channel numbering | |
1148 | 2chan: 0=fl, 1=fr | |
1149 | 4chan: 0=fl, 1=rl, 2=fr, 3=rr | |
1150 | 6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */ | |
1151 | const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3; | |
1152 | int previous_sample, current_sample, next_sample; | |
1153 | int coeff1, coeff2; | |
1154 | int shift; | |
1155 | unsigned int channel; | |
1156 | uint16_t *samplesC; | |
1157 | int count = 0; | |
1158 | int offsets[6]; | |
1159 | ||
1160 | for (channel=0; channel<avctx->channels; channel++) | |
1161 | offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) : | |
1162 | bytestream2_get_le32(&gb)) + | |
1163 | (avctx->channels + 1) * 4; | |
1164 | ||
1165 | for (channel=0; channel<avctx->channels; channel++) { | |
1166 | bytestream2_seek(&gb, offsets[channel], SEEK_SET); | |
1167 | samplesC = samples_p[channel]; | |
1168 | ||
1169 | if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) { | |
1170 | current_sample = sign_extend(bytestream2_get_le16(&gb), 16); | |
1171 | previous_sample = sign_extend(bytestream2_get_le16(&gb), 16); | |
1172 | } else { | |
1173 | current_sample = c->status[channel].predictor; | |
1174 | previous_sample = c->status[channel].prev_sample; | |
1175 | } | |
1176 | ||
1177 | for (count1 = 0; count1 < nb_samples / 28; count1++) { | |
1178 | int byte = bytestream2_get_byte(&gb); | |
1179 | if (byte == 0xEE) { /* only seen in R2 and R3 */ | |
1180 | current_sample = sign_extend(bytestream2_get_be16(&gb), 16); | |
1181 | previous_sample = sign_extend(bytestream2_get_be16(&gb), 16); | |
1182 | ||
1183 | for (count2=0; count2<28; count2++) | |
1184 | *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16); | |
1185 | } else { | |
1186 | coeff1 = ea_adpcm_table[ byte >> 4 ]; | |
1187 | coeff2 = ea_adpcm_table[(byte >> 4) + 4]; | |
1188 | shift = 20 - (byte & 0x0F); | |
1189 | ||
1190 | for (count2=0; count2<28; count2++) { | |
1191 | if (count2 & 1) | |
1192 | next_sample = sign_extend(byte, 4) << shift; | |
1193 | else { | |
1194 | byte = bytestream2_get_byte(&gb); | |
1195 | next_sample = sign_extend(byte >> 4, 4) << shift; | |
1196 | } | |
1197 | ||
1198 | next_sample += (current_sample * coeff1) + | |
1199 | (previous_sample * coeff2); | |
1200 | next_sample = av_clip_int16(next_sample >> 8); | |
1201 | ||
1202 | previous_sample = current_sample; | |
1203 | current_sample = next_sample; | |
1204 | *samplesC++ = current_sample; | |
1205 | } | |
1206 | } | |
1207 | } | |
1208 | if (!count) { | |
1209 | count = count1; | |
1210 | } else if (count != count1) { | |
1211 | av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n"); | |
1212 | count = FFMAX(count, count1); | |
1213 | } | |
1214 | ||
1215 | if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) { | |
1216 | c->status[channel].predictor = current_sample; | |
1217 | c->status[channel].prev_sample = previous_sample; | |
1218 | } | |
1219 | } | |
1220 | ||
1221 | frame->nb_samples = count * 28; | |
1222 | bytestream2_seek(&gb, 0, SEEK_END); | |
1223 | break; | |
1224 | } | |
1225 | case AV_CODEC_ID_ADPCM_EA_XAS: | |
1226 | for (channel=0; channel<avctx->channels; channel++) { | |
1227 | int coeff[2][4], shift[4]; | |
1228 | int16_t *s = samples_p[channel]; | |
1229 | for (n = 0; n < 4; n++, s += 32) { | |
1230 | int val = sign_extend(bytestream2_get_le16u(&gb), 16); | |
1231 | for (i=0; i<2; i++) | |
1232 | coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i]; | |
1233 | s[0] = val & ~0x0F; | |
1234 | ||
1235 | val = sign_extend(bytestream2_get_le16u(&gb), 16); | |
1236 | shift[n] = 20 - (val & 0x0F); | |
1237 | s[1] = val & ~0x0F; | |
1238 | } | |
1239 | ||
1240 | for (m=2; m<32; m+=2) { | |
1241 | s = &samples_p[channel][m]; | |
1242 | for (n = 0; n < 4; n++, s += 32) { | |
1243 | int level, pred; | |
1244 | int byte = bytestream2_get_byteu(&gb); | |
1245 | ||
1246 | level = sign_extend(byte >> 4, 4) << shift[n]; | |
1247 | pred = s[-1] * coeff[0][n] + s[-2] * coeff[1][n]; | |
1248 | s[0] = av_clip_int16((level + pred + 0x80) >> 8); | |
1249 | ||
1250 | level = sign_extend(byte, 4) << shift[n]; | |
1251 | pred = s[0] * coeff[0][n] + s[-1] * coeff[1][n]; | |
1252 | s[1] = av_clip_int16((level + pred + 0x80) >> 8); | |
1253 | } | |
1254 | } | |
1255 | } | |
1256 | break; | |
1257 | case AV_CODEC_ID_ADPCM_IMA_AMV: | |
1258 | c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); | |
1259 | c->status[0].step_index = bytestream2_get_le16u(&gb); | |
1260 | bytestream2_skipu(&gb, 4); | |
1261 | if (c->status[0].step_index > 88u) { | |
1262 | av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", | |
1263 | c->status[0].step_index); | |
1264 | return AVERROR_INVALIDDATA; | |
1265 | } | |
1266 | ||
1267 | for (n = nb_samples >> (1 - st); n > 0; n--) { | |
1268 | int v = bytestream2_get_byteu(&gb); | |
1269 | ||
1270 | *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3); | |
1271 | *samples++ = adpcm_ima_expand_nibble(&c->status[0], v & 0xf, 3); | |
1272 | } | |
1273 | break; | |
1274 | case AV_CODEC_ID_ADPCM_IMA_SMJPEG: | |
1275 | for (i = 0; i < avctx->channels; i++) { | |
1276 | c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16); | |
1277 | c->status[i].step_index = bytestream2_get_byteu(&gb); | |
1278 | bytestream2_skipu(&gb, 1); | |
1279 | if (c->status[i].step_index > 88u) { | |
1280 | av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", | |
1281 | c->status[i].step_index); | |
1282 | return AVERROR_INVALIDDATA; | |
1283 | } | |
1284 | } | |
1285 | ||
1286 | for (n = nb_samples >> (1 - st); n > 0; n--) { | |
1287 | int v = bytestream2_get_byteu(&gb); | |
1288 | ||
1289 | *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4, 3); | |
1290 | *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf, 3); | |
1291 | } | |
1292 | break; | |
1293 | case AV_CODEC_ID_ADPCM_CT: | |
1294 | for (n = nb_samples >> (1 - st); n > 0; n--) { | |
1295 | int v = bytestream2_get_byteu(&gb); | |
1296 | *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 ); | |
1297 | *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F); | |
1298 | } | |
1299 | break; | |
1300 | case AV_CODEC_ID_ADPCM_SBPRO_4: | |
1301 | case AV_CODEC_ID_ADPCM_SBPRO_3: | |
1302 | case AV_CODEC_ID_ADPCM_SBPRO_2: | |
1303 | if (!c->status[0].step_index) { | |
1304 | /* the first byte is a raw sample */ | |
1305 | *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80); | |
1306 | if (st) | |
1307 | *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80); | |
1308 | c->status[0].step_index = 1; | |
1309 | nb_samples--; | |
1310 | } | |
1311 | if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) { | |
1312 | for (n = nb_samples >> (1 - st); n > 0; n--) { | |
1313 | int byte = bytestream2_get_byteu(&gb); | |
1314 | *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1315 | byte >> 4, 4, 0); | |
1316 | *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], | |
1317 | byte & 0x0F, 4, 0); | |
1318 | } | |
1319 | } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) { | |
1320 | for (n = (nb_samples<<st) / 3; n > 0; n--) { | |
1321 | int byte = bytestream2_get_byteu(&gb); | |
1322 | *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1323 | byte >> 5 , 3, 0); | |
1324 | *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1325 | (byte >> 2) & 0x07, 3, 0); | |
1326 | *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1327 | byte & 0x03, 2, 0); | |
1328 | } | |
1329 | } else { | |
1330 | for (n = nb_samples >> (2 - st); n > 0; n--) { | |
1331 | int byte = bytestream2_get_byteu(&gb); | |
1332 | *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1333 | byte >> 6 , 2, 2); | |
1334 | *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], | |
1335 | (byte >> 4) & 0x03, 2, 2); | |
1336 | *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1337 | (byte >> 2) & 0x03, 2, 2); | |
1338 | *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], | |
1339 | byte & 0x03, 2, 2); | |
1340 | } | |
1341 | } | |
1342 | break; | |
1343 | case AV_CODEC_ID_ADPCM_SWF: | |
1344 | adpcm_swf_decode(avctx, buf, buf_size, samples); | |
1345 | bytestream2_seek(&gb, 0, SEEK_END); | |
1346 | break; | |
1347 | case AV_CODEC_ID_ADPCM_YAMAHA: | |
1348 | for (n = nb_samples >> (1 - st); n > 0; n--) { | |
1349 | int v = bytestream2_get_byteu(&gb); | |
1350 | *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F); | |
1351 | *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 ); | |
1352 | } | |
1353 | break; | |
1354 | case AV_CODEC_ID_ADPCM_AFC: | |
1355 | { | |
1356 | int samples_per_block; | |
1357 | int blocks; | |
1358 | ||
1359 | if (avctx->extradata && avctx->extradata_size == 1 && avctx->extradata[0]) { | |
1360 | samples_per_block = avctx->extradata[0] / 16; | |
1361 | blocks = nb_samples / avctx->extradata[0]; | |
1362 | } else { | |
1363 | samples_per_block = nb_samples / 16; | |
1364 | blocks = 1; | |
1365 | } | |
1366 | ||
1367 | for (m = 0; m < blocks; m++) { | |
1368 | for (channel = 0; channel < avctx->channels; channel++) { | |
1369 | int prev1 = c->status[channel].sample1; | |
1370 | int prev2 = c->status[channel].sample2; | |
1371 | ||
1372 | samples = samples_p[channel] + m * 16; | |
1373 | /* Read in every sample for this channel. */ | |
1374 | for (i = 0; i < samples_per_block; i++) { | |
1375 | int byte = bytestream2_get_byteu(&gb); | |
1376 | int scale = 1 << (byte >> 4); | |
1377 | int index = byte & 0xf; | |
1378 | int factor1 = ff_adpcm_afc_coeffs[0][index]; | |
1379 | int factor2 = ff_adpcm_afc_coeffs[1][index]; | |
1380 | ||
1381 | /* Decode 16 samples. */ | |
1382 | for (n = 0; n < 16; n++) { | |
1383 | int32_t sampledat; | |
1384 | ||
1385 | if (n & 1) { | |
1386 | sampledat = sign_extend(byte, 4); | |
1387 | } else { | |
1388 | byte = bytestream2_get_byteu(&gb); | |
1389 | sampledat = sign_extend(byte >> 4, 4); | |
1390 | } | |
1391 | ||
1392 | sampledat = ((prev1 * factor1 + prev2 * factor2) + | |
1393 | ((sampledat * scale) << 11)) >> 11; | |
1394 | *samples = av_clip_int16(sampledat); | |
1395 | prev2 = prev1; | |
1396 | prev1 = *samples++; | |
1397 | } | |
1398 | } | |
1399 | ||
1400 | c->status[channel].sample1 = prev1; | |
1401 | c->status[channel].sample2 = prev2; | |
1402 | } | |
1403 | } | |
1404 | bytestream2_seek(&gb, 0, SEEK_END); | |
1405 | break; | |
1406 | } | |
1407 | case AV_CODEC_ID_ADPCM_THP: | |
1408 | { | |
1409 | int table[6][16]; | |
1410 | int ch; | |
1411 | ||
1412 | if (avctx->extradata) { | |
1413 | GetByteContext tb; | |
1414 | if (avctx->extradata_size < 32 * avctx->channels) { | |
1415 | av_log(avctx, AV_LOG_ERROR, "Missing coeff table\n"); | |
1416 | return AVERROR_INVALIDDATA; | |
1417 | } | |
1418 | ||
1419 | bytestream2_init(&tb, avctx->extradata, avctx->extradata_size); | |
1420 | for (i = 0; i < avctx->channels; i++) | |
1421 | for (n = 0; n < 16; n++) | |
1422 | table[i][n] = sign_extend(bytestream2_get_be16u(&tb), 16); | |
1423 | } else { | |
1424 | for (i = 0; i < avctx->channels; i++) | |
1425 | for (n = 0; n < 16; n++) | |
1426 | table[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16); | |
1427 | ||
1428 | /* Initialize the previous sample. */ | |
1429 | for (i = 0; i < avctx->channels; i++) { | |
1430 | c->status[i].sample1 = sign_extend(bytestream2_get_be16u(&gb), 16); | |
1431 | c->status[i].sample2 = sign_extend(bytestream2_get_be16u(&gb), 16); | |
1432 | } | |
1433 | } | |
1434 | ||
1435 | for (ch = 0; ch < avctx->channels; ch++) { | |
1436 | samples = samples_p[ch]; | |
1437 | ||
1438 | /* Read in every sample for this channel. */ | |
1439 | for (i = 0; i < nb_samples / 14; i++) { | |
1440 | int byte = bytestream2_get_byteu(&gb); | |
1441 | int index = (byte >> 4) & 7; | |
1442 | unsigned int exp = byte & 0x0F; | |
1443 | int factor1 = table[ch][index * 2]; | |
1444 | int factor2 = table[ch][index * 2 + 1]; | |
1445 | ||
1446 | /* Decode 14 samples. */ | |
1447 | for (n = 0; n < 14; n++) { | |
1448 | int32_t sampledat; | |
1449 | ||
1450 | if (n & 1) { | |
1451 | sampledat = sign_extend(byte, 4); | |
1452 | } else { | |
1453 | byte = bytestream2_get_byteu(&gb); | |
1454 | sampledat = sign_extend(byte >> 4, 4); | |
1455 | } | |
1456 | ||
1457 | sampledat = ((c->status[ch].sample1 * factor1 | |
1458 | + c->status[ch].sample2 * factor2) >> 11) + (sampledat << exp); | |
1459 | *samples = av_clip_int16(sampledat); | |
1460 | c->status[ch].sample2 = c->status[ch].sample1; | |
1461 | c->status[ch].sample1 = *samples++; | |
1462 | } | |
1463 | } | |
1464 | } | |
1465 | break; | |
1466 | } | |
1467 | case AV_CODEC_ID_ADPCM_DTK: | |
1468 | for (channel = 0; channel < avctx->channels; channel++) { | |
1469 | samples = samples_p[channel]; | |
1470 | ||
1471 | /* Read in every sample for this channel. */ | |
1472 | for (i = 0; i < nb_samples / 28; i++) { | |
1473 | int byte, header; | |
1474 | if (channel) | |
1475 | bytestream2_skipu(&gb, 1); | |
1476 | header = bytestream2_get_byteu(&gb); | |
1477 | bytestream2_skipu(&gb, 3 - channel); | |
1478 | ||
1479 | /* Decode 28 samples. */ | |
1480 | for (n = 0; n < 28; n++) { | |
1481 | int32_t sampledat, prev; | |
1482 | ||
1483 | switch (header >> 4) { | |
1484 | case 1: | |
1485 | prev = (c->status[channel].sample1 * 0x3c); | |
1486 | break; | |
1487 | case 2: | |
1488 | prev = (c->status[channel].sample1 * 0x73) - (c->status[channel].sample2 * 0x34); | |
1489 | break; | |
1490 | case 3: | |
1491 | prev = (c->status[channel].sample1 * 0x62) - (c->status[channel].sample2 * 0x37); | |
1492 | break; | |
1493 | default: | |
1494 | prev = 0; | |
1495 | } | |
1496 | ||
1497 | prev = av_clip((prev + 0x20) >> 6, -0x200000, 0x1fffff); | |
1498 | ||
1499 | byte = bytestream2_get_byteu(&gb); | |
1500 | if (!channel) | |
1501 | sampledat = sign_extend(byte, 4); | |
1502 | else | |
1503 | sampledat = sign_extend(byte >> 4, 4); | |
1504 | ||
1505 | sampledat = (((sampledat << 12) >> (header & 0xf)) << 6) + prev; | |
1506 | *samples++ = av_clip_int16(sampledat >> 6); | |
1507 | c->status[channel].sample2 = c->status[channel].sample1; | |
1508 | c->status[channel].sample1 = sampledat; | |
1509 | } | |
1510 | } | |
1511 | if (!channel) | |
1512 | bytestream2_seek(&gb, 0, SEEK_SET); | |
1513 | } | |
1514 | break; | |
1515 | ||
1516 | default: | |
1517 | return -1; | |
1518 | } | |
1519 | ||
1520 | if (avpkt->size && bytestream2_tell(&gb) == 0) { | |
1521 | av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n"); | |
1522 | return AVERROR_INVALIDDATA; | |
1523 | } | |
1524 | ||
1525 | *got_frame_ptr = 1; | |
1526 | ||
1527 | return bytestream2_tell(&gb); | |
1528 | } | |
1529 | ||
1530 | ||
1531 | static const enum AVSampleFormat sample_fmts_s16[] = { AV_SAMPLE_FMT_S16, | |
1532 | AV_SAMPLE_FMT_NONE }; | |
1533 | static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16P, | |
1534 | AV_SAMPLE_FMT_NONE }; | |
1535 | static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16, | |
1536 | AV_SAMPLE_FMT_S16P, | |
1537 | AV_SAMPLE_FMT_NONE }; | |
1538 | ||
1539 | #define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \ | |
1540 | AVCodec ff_ ## name_ ## _decoder = { \ | |
1541 | .name = #name_, \ | |
1542 | .long_name = NULL_IF_CONFIG_SMALL(long_name_), \ | |
1543 | .type = AVMEDIA_TYPE_AUDIO, \ | |
1544 | .id = id_, \ | |
1545 | .priv_data_size = sizeof(ADPCMDecodeContext), \ | |
1546 | .init = adpcm_decode_init, \ | |
1547 | .decode = adpcm_decode_frame, \ | |
1548 | .capabilities = CODEC_CAP_DR1, \ | |
1549 | .sample_fmts = sample_fmts_, \ | |
1550 | } | |
1551 | ||
1552 | /* Note: Do not forget to add new entries to the Makefile as well. */ | |
1553 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM, sample_fmts_s16p, adpcm_4xm, "ADPCM 4X Movie"); | |
1554 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_AFC, sample_fmts_s16p, adpcm_afc, "ADPCM Nintendo Gamecube AFC"); | |
1555 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT, sample_fmts_s16, adpcm_ct, "ADPCM Creative Technology"); | |
1556 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_DTK, sample_fmts_s16p, adpcm_dtk, "ADPCM Nintendo Gamecube DTK"); | |
1557 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA, sample_fmts_s16, adpcm_ea, "ADPCM Electronic Arts"); | |
1558 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_MAXIS_XA, sample_fmts_s16, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA"); | |
1559 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1, sample_fmts_s16p, adpcm_ea_r1, "ADPCM Electronic Arts R1"); | |
1560 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R2, sample_fmts_s16p, adpcm_ea_r2, "ADPCM Electronic Arts R2"); | |
1561 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R3, sample_fmts_s16p, adpcm_ea_r3, "ADPCM Electronic Arts R3"); | |
1562 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS, sample_fmts_s16p, adpcm_ea_xas, "ADPCM Electronic Arts XAS"); | |
1563 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_AMV, sample_fmts_s16, adpcm_ima_amv, "ADPCM IMA AMV"); | |
1564 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APC, sample_fmts_s16, adpcm_ima_apc, "ADPCM IMA CRYO APC"); | |
1565 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK3, sample_fmts_s16, adpcm_ima_dk3, "ADPCM IMA Duck DK3"); | |
1566 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4, sample_fmts_s16, adpcm_ima_dk4, "ADPCM IMA Duck DK4"); | |
1567 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_EACS, sample_fmts_s16, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS"); | |
1568 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_SEAD, sample_fmts_s16, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD"); | |
1569 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ISS, sample_fmts_s16, adpcm_ima_iss, "ADPCM IMA Funcom ISS"); | |
1570 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_OKI, sample_fmts_s16, adpcm_ima_oki, "ADPCM IMA Dialogic OKI"); | |
1571 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT, sample_fmts_s16p, adpcm_ima_qt, "ADPCM IMA QuickTime"); | |
1572 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_RAD, sample_fmts_s16, adpcm_ima_rad, "ADPCM IMA Radical"); | |
1573 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG, sample_fmts_s16, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG"); | |
1574 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV, sample_fmts_s16p, adpcm_ima_wav, "ADPCM IMA WAV"); | |
1575 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS, sample_fmts_both, adpcm_ima_ws, "ADPCM IMA Westwood"); | |
1576 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS, sample_fmts_s16, adpcm_ms, "ADPCM Microsoft"); | |
1577 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2, sample_fmts_s16, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit"); | |
1578 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_3, sample_fmts_s16, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit"); | |
1579 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_4, sample_fmts_s16, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit"); | |
1580 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_SWF, sample_fmts_s16, adpcm_swf, "ADPCM Shockwave Flash"); | |
1581 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP, sample_fmts_s16p, adpcm_thp, "ADPCM Nintendo Gamecube THP"); | |
1582 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA, sample_fmts_s16p, adpcm_xa, "ADPCM CDROM XA"); | |
1583 | ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA, sample_fmts_s16, adpcm_yamaha, "ADPCM Yamaha"); |