FFmpeg
Loading...
Searching...
No Matches
adpcm.c
Go to the documentation of this file.
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 * Argonaut Games ADPCM decoder by Zane van Iperen (zane@zanevaniperen.com)
16 * Simon & Schuster Interactive ADPCM decoder by Zane van Iperen (zane@zanevaniperen.com)
17 * Ubisoft ADPCM decoder by Zane van Iperen (zane@zanevaniperen.com)
18 * High Voltage Software ALP decoder by Zane van Iperen (zane@zanevaniperen.com)
19 * Cunning Developments decoder by Zane van Iperen (zane@zanevaniperen.com)
20 * Sanyo LD-ADPCM decoder by Peter Ross (pross@xvid.org)
21 *
22 * This file is part of FFmpeg.
23 *
24 * FFmpeg is free software; you can redistribute it and/or
25 * modify it under the terms of the GNU Lesser General Public
26 * License as published by the Free Software Foundation; either
27 * version 2.1 of the License, or (at your option) any later version.
28 *
29 * FFmpeg is distributed in the hope that it will be useful,
30 * but WITHOUT ANY WARRANTY; without even the implied warranty of
31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
32 * Lesser General Public License for more details.
33 *
34 * You should have received a copy of the GNU Lesser General Public
35 * License along with FFmpeg; if not, write to the Free Software
36 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
37 */
38
39#include "config_components.h"
40
41#include "avcodec.h"
42#include "get_bits.h"
43#include "bytestream.h"
44#include "adpcm.h"
45#include "adpcm_data.h"
46#include "codec_internal.h"
47#include "decode.h"
48
49#include "libavutil/attributes.h"
50
51/**
52 * @file
53 * ADPCM decoders
54 * Features and limitations:
55 *
56 * Reference documents:
57 * http://wiki.multimedia.cx/index.php?title=Category:ADPCM_Audio_Codecs
58 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html [dead]
59 * http://www.geocities.com/SiliconValley/8682/aud3.txt [dead]
60 * http://openquicktime.sourceforge.net/
61 * XAnim sources (xa_codec.c) http://xanim.polter.net/
62 * http://www.cs.ucla.edu/~leec/mediabench/applications.html [dead]
63 * SoX source code http://sox.sourceforge.net/
64 *
65 * CD-ROM XA:
66 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html [dead]
67 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html [dead]
68 * readstr http://www.geocities.co.jp/Playtown/2004/
69 */
70
71#define CASE_0(codec_id, ...)
72#define CASE_1(codec_id, ...) \
73 case codec_id: \
74 { __VA_ARGS__ } \
75 break;
76#define CASE_2(enabled, codec_id, ...) \
77 CASE_ ## enabled(codec_id, __VA_ARGS__)
78#define CASE_3(config, codec_id, ...) \
79 CASE_2(config, codec_id, __VA_ARGS__)
80#define CASE(codec, ...) \
81 CASE_3(CONFIG_ ## codec ## _DECODER, AV_CODEC_ID_ ## codec, __VA_ARGS__)
82
83/* These are for CD-ROM XA ADPCM */
84static const int8_t xa_adpcm_table[5][2] = {
85 { 0, 0 },
86 { 60, 0 },
87 { 115, -52 },
88 { 98, -55 },
89 { 122, -60 }
90};
91
92static const int16_t afc_coeffs[2][16] = {
93 { 0, 2048, 0, 1024, 4096, 3584, 3072, 4608, 4200, 4800, 5120, 2048, 1024, -1024, -1024, -2048 },
94 { 0, 0, 2048, 1024, -2048, -1536, -1024, -2560, -2248, -2300, -3072, -2048, -1024, 1024, 0, 0 }
95};
96
97static const int16_t ea_adpcm_table[] = {
98 0, 240, 460, 392,
99 0, 0, -208, -220,
100 0, 1, 3, 4,
101 7, 8, 10, 11,
102 0, -1, -3, -4
103};
104
105/*
106 * Dumped from the binaries:
107 * - FantasticJourney.exe - 0x794D2, DGROUP:0x47A4D2
108 * - BigRaceUSA.exe - 0x9B8AA, DGROUP:0x49C4AA
109 * - Timeshock!.exe - 0x8506A, DGROUP:0x485C6A
110 */
111static const int8_t ima_cunning_index_table[9] = {
112 -1, -1, -1, -1, 1, 2, 3, 4, -1
113};
114
115/*
116 * Dumped from the binaries:
117 * - FantasticJourney.exe - 0x79458, DGROUP:0x47A458
118 * - BigRaceUSA.exe - 0x9B830, DGROUP:0x49C430
119 * - Timeshock!.exe - 0x84FF0, DGROUP:0x485BF0
120 */
121static const int16_t ima_cunning_step_table[61] = {
122 1, 1, 1, 1, 2, 2, 3, 3, 4, 5,
123 6, 7, 8, 10, 12, 14, 16, 20, 24, 28,
124 32, 40, 48, 56, 64, 80, 96, 112, 128, 160,
125 192, 224, 256, 320, 384, 448, 512, 640, 768, 896,
126 1024, 1280, 1536, 1792, 2048, 2560, 3072, 3584, 4096, 5120,
127 6144, 7168, 8192, 10240, 12288, 14336, 16384, 20480, 24576, 28672, 0
128};
129
130static const int8_t adpcm_index_table2[4] = {
131 -1, 2,
132 -1, 2,
133};
134
135static const int8_t adpcm_index_table3[8] = {
136 -1, -1, 1, 2,
137 -1, -1, 1, 2,
138};
139
140static const int8_t adpcm_index_table5[32] = {
141 -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16,
142 -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16,
143};
144
145static const int8_t * const adpcm_index_tables[4] = {
146 &adpcm_index_table2[0],
147 &adpcm_index_table3[0],
148 &ff_adpcm_index_table[0],
149 &adpcm_index_table5[0],
150};
151
152static const int16_t mtaf_stepsize[32][16] = {
153 { 1, 5, 9, 13, 16, 20, 24, 28,
154 -1, -5, -9, -13, -16, -20, -24, -28, },
155 { 2, 6, 11, 15, 20, 24, 29, 33,
156 -2, -6, -11, -15, -20, -24, -29, -33, },
157 { 2, 7, 13, 18, 23, 28, 34, 39,
158 -2, -7, -13, -18, -23, -28, -34, -39, },
159 { 3, 9, 15, 21, 28, 34, 40, 46,
160 -3, -9, -15, -21, -28, -34, -40, -46, },
161 { 3, 11, 18, 26, 33, 41, 48, 56,
162 -3, -11, -18, -26, -33, -41, -48, -56, },
163 { 4, 13, 22, 31, 40, 49, 58, 67,
164 -4, -13, -22, -31, -40, -49, -58, -67, },
165 { 5, 16, 26, 37, 48, 59, 69, 80,
166 -5, -16, -26, -37, -48, -59, -69, -80, },
167 { 6, 19, 31, 44, 57, 70, 82, 95,
168 -6, -19, -31, -44, -57, -70, -82, -95, },
169 { 7, 22, 38, 53, 68, 83, 99, 114,
170 -7, -22, -38, -53, -68, -83, -99, -114, },
171 { 9, 27, 45, 63, 81, 99, 117, 135,
172 -9, -27, -45, -63, -81, -99, -117, -135, },
173 { 10, 32, 53, 75, 96, 118, 139, 161,
174 -10, -32, -53, -75, -96, -118, -139, -161, },
175 { 12, 38, 64, 90, 115, 141, 167, 193,
176 -12, -38, -64, -90, -115, -141, -167, -193, },
177 { 15, 45, 76, 106, 137, 167, 198, 228,
178 -15, -45, -76, -106, -137, -167, -198, -228, },
179 { 18, 54, 91, 127, 164, 200, 237, 273,
180 -18, -54, -91, -127, -164, -200, -237, -273, },
181 { 21, 65, 108, 152, 195, 239, 282, 326,
182 -21, -65, -108, -152, -195, -239, -282, -326, },
183 { 25, 77, 129, 181, 232, 284, 336, 388,
184 -25, -77, -129, -181, -232, -284, -336, -388, },
185 { 30, 92, 153, 215, 276, 338, 399, 461,
186 -30, -92, -153, -215, -276, -338, -399, -461, },
187 { 36, 109, 183, 256, 329, 402, 476, 549,
188 -36, -109, -183, -256, -329, -402, -476, -549, },
189 { 43, 130, 218, 305, 392, 479, 567, 654,
190 -43, -130, -218, -305, -392, -479, -567, -654, },
191 { 52, 156, 260, 364, 468, 572, 676, 780,
192 -52, -156, -260, -364, -468, -572, -676, -780, },
193 { 62, 186, 310, 434, 558, 682, 806, 930,
194 -62, -186, -310, -434, -558, -682, -806, -930, },
195 { 73, 221, 368, 516, 663, 811, 958, 1106,
196 -73, -221, -368, -516, -663, -811, -958, -1106, },
197 { 87, 263, 439, 615, 790, 966, 1142, 1318,
198 -87, -263, -439, -615, -790, -966, -1142, -1318, },
199 { 104, 314, 523, 733, 942, 1152, 1361, 1571,
200 -104, -314, -523, -733, -942, -1152, -1361, -1571, },
201 { 124, 374, 623, 873, 1122, 1372, 1621, 1871,
202 -124, -374, -623, -873, -1122, -1372, -1621, -1871, },
203 { 148, 445, 743, 1040, 1337, 1634, 1932, 2229,
204 -148, -445, -743, -1040, -1337, -1634, -1932, -2229, },
205 { 177, 531, 885, 1239, 1593, 1947, 2301, 2655,
206 -177, -531, -885, -1239, -1593, -1947, -2301, -2655, },
207 { 210, 632, 1053, 1475, 1896, 2318, 2739, 3161,
208 -210, -632, -1053, -1475, -1896, -2318, -2739, -3161, },
209 { 251, 753, 1255, 1757, 2260, 2762, 3264, 3766,
210 -251, -753, -1255, -1757, -2260, -2762, -3264, -3766, },
211 { 299, 897, 1495, 2093, 2692, 3290, 3888, 4486,
212 -299, -897, -1495, -2093, -2692, -3290, -3888, -4486, },
213 { 356, 1068, 1781, 2493, 3206, 3918, 4631, 5343,
214 -356, -1068, -1781, -2493, -3206, -3918, -4631, -5343, },
215 { 424, 1273, 2121, 2970, 3819, 4668, 5516, 6365,
216 -424, -1273, -2121, -2970, -3819, -4668, -5516, -6365, },
217};
218
219static const int16_t oki_step_table[49] = {
220 16, 17, 19, 21, 23, 25, 28, 31, 34, 37,
221 41, 45, 50, 55, 60, 66, 73, 80, 88, 97,
222 107, 118, 130, 143, 157, 173, 190, 209, 230, 253,
223 279, 307, 337, 371, 408, 449, 494, 544, 598, 658,
224 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552
225};
226
227// padded to zero where table size is less then 16
228static const int8_t swf_index_tables[4][16] = {
229 /*2*/ { -1, 2 },
230 /*3*/ { -1, -1, 2, 4 },
231 /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },
232 /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
233};
234
235static const int8_t zork_index_table[8] = {
236 -1, -1, -1, 1, 4, 7, 10, 12,
237};
238
239static const int8_t mtf_index_table[16] = {
240 8, 6, 4, 2, -1, -1, -1, -1,
241 -1, -1, -1, -1, 2, 4, 6, 8,
242};
243
244/* end of tables */
245
246typedef struct ADPCMDecodeContext {
247 ADPCMChannelStatus status[14];
248 int vqa_version; /**< VQA version. Used for ADPCM_IMA_WS */
249 int has_status; /**< Status flag. Reset to 0 after a flush. */
250} ADPCMDecodeContext;
251
252static void adpcm_flush(AVCodecContext *avctx);
253
254static av_cold int adpcm_decode_init(AVCodecContext * avctx)
255{
256 ADPCMDecodeContext *c = avctx->priv_data;
257 unsigned int min_channels = 1;
258 unsigned int max_channels = 2;
259
260 adpcm_flush(avctx);
261
262 switch(avctx->codec->id) {
263 case AV_CODEC_ID_ADPCM_IMA_AMV:
264 case AV_CODEC_ID_ADPCM_N64:
265 max_channels = 1;
266 break;
267 case AV_CODEC_ID_ADPCM_SANYO:
268 max_channels = 2;
269 break;
270 case AV_CODEC_ID_ADPCM_AFC:
271 case AV_CODEC_ID_ADPCM_EA_R1:
272 case AV_CODEC_ID_ADPCM_EA_R2:
273 case AV_CODEC_ID_ADPCM_EA_R3:
274 case AV_CODEC_ID_ADPCM_EA_XAS:
275 case AV_CODEC_ID_ADPCM_MS:
276 max_channels = 6;
277 break;
278 case AV_CODEC_ID_ADPCM_MTAF:
279 min_channels = 2;
280 max_channels = 8;
281 if (avctx->ch_layout.nb_channels & 1) {
282 avpriv_request_sample(avctx, "channel count %d", avctx->ch_layout.nb_channels);
283 return AVERROR_PATCHWELCOME;
284 }
285 break;
286 case AV_CODEC_ID_ADPCM_DTK:
287 min_channels = 2;
288 break;
289 case AV_CODEC_ID_ADPCM_PSX:
290 max_channels = 8;
291 if (avctx->ch_layout.nb_channels <= 0 ||
292 avctx->block_align % (16 * avctx->ch_layout.nb_channels))
293 return AVERROR_INVALIDDATA;
294 break;
295 case AV_CODEC_ID_ADPCM_PSXC:
296 max_channels = 8;
297 if (avctx->ch_layout.nb_channels <= 0 || avctx->block_align <= 0 ||
298 avctx->block_align % avctx->ch_layout.nb_channels)
299 return AVERROR_INVALIDDATA;
300 break;
301 case AV_CODEC_ID_ADPCM_IMA_DAT4:
302 case AV_CODEC_ID_ADPCM_THP:
303 case AV_CODEC_ID_ADPCM_THP_LE:
304 max_channels = 14;
305 break;
306 }
307 if (avctx->ch_layout.nb_channels < min_channels ||
308 avctx->ch_layout.nb_channels > max_channels) {
309 av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
310 return AVERROR(EINVAL);
311 }
312
313 switch(avctx->codec->id) {
314 case AV_CODEC_ID_ADPCM_IMA_WAV:
315 if (avctx->bits_per_coded_sample < 2 || avctx->bits_per_coded_sample > 5)
316 return AVERROR_INVALIDDATA;
317 break;
318 case AV_CODEC_ID_ADPCM_ARGO:
319 if (avctx->bits_per_coded_sample != 4 ||
320 avctx->block_align != 17 * avctx->ch_layout.nb_channels)
321 return AVERROR_INVALIDDATA;
322 break;
323 case AV_CODEC_ID_ADPCM_SANYO:
324 if (avctx->bits_per_coded_sample < 3 || avctx->bits_per_coded_sample > 5)
325 return AVERROR_INVALIDDATA;
326 break;
327 case AV_CODEC_ID_ADPCM_IMA_XBOX:
328 if (avctx->bits_per_coded_sample != 4)
329 return AVERROR_INVALIDDATA;
330 break;
331 case AV_CODEC_ID_ADPCM_ZORK:
332 if (avctx->bits_per_coded_sample != 8)
333 return AVERROR_INVALIDDATA;
334 break;
335 default:
336 break;
337 }
338
339 switch (avctx->codec->id) {
340 case AV_CODEC_ID_ADPCM_AICA:
341 case AV_CODEC_ID_ADPCM_IMA_CUNNING:
342 case AV_CODEC_ID_ADPCM_IMA_DAT4:
343 case AV_CODEC_ID_ADPCM_IMA_QT:
344 case AV_CODEC_ID_ADPCM_IMA_WAV:
345 case AV_CODEC_ID_ADPCM_IMA_XBOX:
346 case AV_CODEC_ID_ADPCM_4XM:
347 case AV_CODEC_ID_ADPCM_XA:
348 case AV_CODEC_ID_ADPCM_XMD:
349 case AV_CODEC_ID_ADPCM_EA_R1:
350 case AV_CODEC_ID_ADPCM_EA_R2:
351 case AV_CODEC_ID_ADPCM_EA_R3:
352 case AV_CODEC_ID_ADPCM_EA_XAS:
353 case AV_CODEC_ID_ADPCM_THP:
354 case AV_CODEC_ID_ADPCM_THP_LE:
355 case AV_CODEC_ID_ADPCM_AFC:
356 case AV_CODEC_ID_ADPCM_DTK:
357 case AV_CODEC_ID_ADPCM_PSX:
358 case AV_CODEC_ID_ADPCM_PSXC:
359 case AV_CODEC_ID_ADPCM_SANYO:
360 case AV_CODEC_ID_ADPCM_MTAF:
361 case AV_CODEC_ID_ADPCM_ARGO:
362 case AV_CODEC_ID_ADPCM_IMA_MOFLEX:
363 case AV_CODEC_ID_ADPCM_N64:
364 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
365 break;
366 case AV_CODEC_ID_ADPCM_IMA_WS:
367 avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
368 AV_SAMPLE_FMT_S16;
369 break;
370 case AV_CODEC_ID_ADPCM_MS:
371 avctx->sample_fmt = avctx->ch_layout.nb_channels > 2 ? AV_SAMPLE_FMT_S16P :
372 AV_SAMPLE_FMT_S16;
373 break;
374 default:
375 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
376 }
377 return 0;
378}
379
380static inline int16_t adpcm_agm_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
381{
382 int delta, pred, step, add;
383
384 pred = c->predictor;
385 delta = nibble & 7;
386 step = c->step;
387 add = (delta * 2 + 1) * step;
388 if (add < 0)
389 add = add + 7;
390
391 if ((nibble & 8) == 0)
392 pred = av_clip(pred + (add >> 3), -32767, 32767);
393 else
394 pred = av_clip(pred - (add >> 3), -32767, 32767);
395
396 switch (delta) {
397 case 7:
398 step *= 0x99;
399 break;
400 case 6:
401 c->step = av_clip(c->step * 2, 127, 24576);
402 c->predictor = pred;
403 return pred;
404 case 5:
405 step *= 0x66;
406 break;
407 case 4:
408 step *= 0x4d;
409 break;
410 default:
411 step *= 0x39;
412 break;
413 }
414
415 if (step < 0)
416 step += 0x3f;
417
418 c->step = step >> 6;
419 c->step = av_clip(c->step, 127, 24576);
420 c->predictor = pred;
421 return pred;
422}
423
424static inline int16_t adpcm_ima_escape_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
425{
426 int step_index;
427 int predictor;
428 int sign, delta, diff, step;
429
430 step = ff_adpcm_step_table[c->step_index];
431 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
432 step_index = av_clip(step_index, 0, 88);
433
434 sign = nibble & 8;
435 delta = nibble & 7;
436 diff = (delta * step) >> 2;
437 predictor = c->predictor;
438 if (sign) predictor -= diff;
439 else predictor += diff;
440
441 c->predictor = av_clip_int16(predictor);
442 c->step_index = step_index;
443
444 return (int16_t)c->predictor;
445}
446
447static inline int16_t adpcm_ima_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
448{
449 int step_index;
450 int predictor;
451 int sign, delta, diff, step;
452
453 step = ff_adpcm_step_table[c->step_index];
454 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
455 step_index = av_clip(step_index, 0, 88);
456
457 sign = nibble & 8;
458 delta = nibble & 7;
459 /* perform direct multiplication instead of series of jumps proposed by
460 * the reference ADPCM implementation since modern CPUs can do the mults
461 * quickly enough */
462 diff = ((2 * delta + 1) * step) >> shift;
463 predictor = c->predictor;
464 if (sign) predictor -= diff;
465 else predictor += diff;
466
467 c->predictor = av_clip_int16(predictor);
468 c->step_index = step_index;
469
470 return (int16_t)c->predictor;
471}
472
473static inline int16_t adpcm_ima_alp_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
474{
475 int step_index;
476 int predictor;
477 int sign, delta, diff, step;
478
479 step = ff_adpcm_step_table[c->step_index];
480 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
481 step_index = av_clip(step_index, 0, 88);
482
483 sign = nibble & 8;
484 delta = nibble & 7;
485 diff = (delta * step) >> shift;
486 predictor = c->predictor;
487 if (sign) predictor -= diff;
488 else predictor += diff;
489
490 c->predictor = av_clip_int16(predictor);
491 c->step_index = step_index;
492
493 return (int16_t)c->predictor;
494}
495
496static inline int16_t adpcm_ima_mtf_expand_nibble(ADPCMChannelStatus *c, int nibble)
497{
498 int step_index, step, delta, predictor;
499
500 step = ff_adpcm_step_table[c->step_index];
501
502 delta = step * (2 * nibble - 15);
503 predictor = c->predictor + delta;
504
505 step_index = c->step_index + mtf_index_table[(unsigned)nibble];
506 c->predictor = av_clip_int16(predictor >> 4);
507 c->step_index = av_clip(step_index, 0, 88);
508
509 return (int16_t)c->predictor;
510}
511
512static inline int16_t adpcm_ima_cunning_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
513{
514 int step_index;
515 int predictor;
516 int step;
517
518 nibble = sign_extend(nibble & 0xF, 4);
519
520 step = ima_cunning_step_table[c->step_index];
521 step_index = c->step_index + ima_cunning_index_table[abs(nibble)];
522 step_index = av_clip(step_index, 0, 60);
523
524 predictor = c->predictor + step * nibble;
525
526 c->predictor = av_clip_int16(predictor);
527 c->step_index = step_index;
528
529 return c->predictor;
530}
531
532static inline int16_t adpcm_ima_wav_expand_nibble(ADPCMChannelStatus *c, GetBitContext *gb, int bps)
533{
534 int nibble, step_index, predictor, sign, delta, diff, step, shift;
535
536 shift = bps - 1;
537 nibble = get_bits_le(gb, bps),
538 step = ff_adpcm_step_table[c->step_index];
539 step_index = c->step_index + adpcm_index_tables[bps - 2][nibble];
540 step_index = av_clip(step_index, 0, 88);
541
542 sign = nibble & (1 << shift);
543 delta = av_zero_extend(nibble, shift);
544 diff = step >> shift;
545 for (int i = 0; i < shift; i++)
546 diff += (step >> (shift-1-i)) * !!(delta & (1 << i));
547 predictor = c->predictor;
548 if (sign) predictor -= diff;
549 else predictor += diff;
550
551 c->predictor = av_clip_int16(predictor);
552 c->step_index = step_index;
553
554 return (int16_t)c->predictor;
555}
556
557int16_t ff_adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble)
558{
559 int step_index;
560 int predictor;
561 int diff, step;
562
563 step = ff_adpcm_step_table[c->step_index];
564 step_index = c->step_index + ff_adpcm_index_table[nibble];
565 step_index = av_clip(step_index, 0, 88);
566
567 diff = step >> 3;
568 if (nibble & 4) diff += step;
569 if (nibble & 2) diff += step >> 1;
570 if (nibble & 1) diff += step >> 2;
571
572 if (nibble & 8)
573 predictor = c->predictor - diff;
574 else
575 predictor = c->predictor + diff;
576
577 c->predictor = av_clip_int16(predictor);
578 c->step_index = step_index;
579
580 return c->predictor;
581}
582
583static void decode_adpcm_ima_hvqm2(AVCodecContext *avctx, int16_t *outbuf, int samples_to_do,
584 int frame_format, GetByteContext *gb)
585{
586 ADPCMDecodeContext *c = avctx->priv_data;
587 int st = avctx->ch_layout.nb_channels == 2;
588 uint8_t nibble;
589
590 for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
591 unsigned tmp;
592
593 switch (frame_format) {
594 case 0: /* combined hist+index */
595 tmp = bytestream2_get_be16(gb);
596 c->status[ch].predictor = sign_extend(tmp & 0xFF80, 16);
597 c->status[ch].step_index = tmp & 0x7f;
598 *outbuf++ = c->status[ch].predictor;
599 samples_to_do--;
600 break;
601 default:
602 break;
603 }
604
605 c->status[ch].step_index = av_clip(c->status[ch].step_index, 0, 88);
606 }
607
608 for (int i = 0; i < samples_to_do; i++) {
609 if (!(i&1)) {
610 nibble = bytestream2_get_byte(gb);
611 *outbuf++ = ff_adpcm_ima_qt_expand_nibble(&c->status[st], nibble >> 4);
612 } else {
613 *outbuf++ = ff_adpcm_ima_qt_expand_nibble(&c->status[ 0], nibble & 0xF);
614 }
615 }
616
617 bytestream2_seek(gb, 0, SEEK_END);
618}
619
620static void decode_adpcm_ima_hvqm4(AVCodecContext *avctx, int16_t *outbuf, int samples_to_do,
621 int frame_format, GetByteContext *gb)
622{
623 ADPCMDecodeContext *c = avctx->priv_data;
624 int st = avctx->ch_layout.nb_channels == 2;
625 unsigned tmp;
626
627 for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
628 switch (frame_format) {
629 case 1: /* combined hist+index */
630 tmp = bytestream2_get_be16(gb);
631 c->status[ch].predictor = sign_extend(tmp & 0xFF80, 16);
632 c->status[ch].step_index = tmp & 0x7f;
633 break;
634 case 2: /* no hist/index (continues from previous frame) */
635 default:
636 break;
637 case 3: /* separate hist+index */
638 tmp = bytestream2_get_be16(gb);
639 c->status[ch].predictor = sign_extend(tmp, 16);
640 c->status[ch].step_index = bytestream2_get_byte(gb);
641 break;
642 }
643
644 c->status[ch].step_index = av_clip(c->status[ch].step_index, 0, 88);
645 }
646
647 if (frame_format == 1 || frame_format == 3) {
648 for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
649 *outbuf++ = (int16_t)c->status[st - ch].predictor;
650 samples_to_do--;
651 }
652
653 for (int i = 0; i < samples_to_do; i += 1+(!st)) {
654 uint8_t nibble = bytestream2_get_byte(gb);
655
656 *outbuf++ = ff_adpcm_ima_qt_expand_nibble(&c->status[st], nibble & 0xF);
657 *outbuf++ = ff_adpcm_ima_qt_expand_nibble(&c->status[ 0], nibble >> 4);
658 }
659
660 bytestream2_seek(gb, 0, SEEK_END);
661}
662
663static inline int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
664{
665 int predictor;
666
667 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
668 predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
669
670 c->sample2 = c->sample1;
671 c->sample1 = av_clip_int16(predictor);
672 c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
673 if (c->idelta < 16) c->idelta = 16;
674 if (c->idelta > INT_MAX/768) {
675 av_log(NULL, AV_LOG_WARNING, "idelta overflow\n");
676 c->idelta = INT_MAX/768;
677 }
678
679 return c->sample1;
680}
681
682static inline int16_t adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)
683{
684 int step_index, predictor, sign, delta, diff, step;
685
686 step = oki_step_table[c->step_index];
687 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
688 step_index = av_clip(step_index, 0, 48);
689
690 sign = nibble & 8;
691 delta = nibble & 7;
692 diff = ((2 * delta + 1) * step) >> 3;
693 predictor = c->predictor;
694 if (sign) predictor -= diff;
695 else predictor += diff;
696
697 c->predictor = av_clip_intp2(predictor, 11);
698 c->step_index = step_index;
699
700 return c->predictor * 16;
701}
702
703static inline int16_t adpcm_ct_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
704{
705 int sign, delta, diff;
706 int new_step;
707
708 sign = nibble & 8;
709 delta = nibble & 7;
710 /* perform direct multiplication instead of series of jumps proposed by
711 * the reference ADPCM implementation since modern CPUs can do the mults
712 * quickly enough */
713 diff = ((2 * delta + 1) * c->step) >> 3;
714 /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
715 c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
716 c->predictor = av_clip_int16(c->predictor);
717 /* calculate new step and clamp it to range 511..32767 */
718 new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
719 c->step = av_clip(new_step, 511, 32767);
720
721 return (int16_t)c->predictor;
722}
723
724static inline int16_t adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int size, int shift)
725{
726 int sign, delta, diff;
727
728 sign = nibble & (1<<(size-1));
729 delta = nibble & ((1<<(size-1))-1);
730 diff = delta << (7 + c->step + shift);
731
732 /* clamp result */
733 c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
734
735 /* calculate new step */
736 if (delta >= (2*size - 3) && c->step < 3)
737 c->step++;
738 else if (delta == 0 && c->step > 0)
739 c->step--;
740
741 return (int16_t) c->predictor;
742}
743
744static inline int16_t adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
745{
746 if(!c->step) {
747 c->predictor = 0;
748 c->step = 127;
749 }
750
751 c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
752 c->predictor = av_clip_int16(c->predictor);
753 c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
754 c->step = av_clip(c->step, 127, 24576);
755 return c->predictor;
756}
757
758static inline int16_t adpcm_mtaf_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
759{
760 c->predictor += mtaf_stepsize[c->step][nibble];
761 c->predictor = av_clip_int16(c->predictor);
762 c->step += ff_adpcm_index_table[nibble];
763 c->step = av_clip_uintp2(c->step, 5);
764 return c->predictor;
765}
766
767static inline int16_t adpcm_circus_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
768{
769 int32_t sample = c->predictor;
770 int32_t scale = c->step;
771 int32_t code = sign_extend(nibble, 8);
772
773 sample += code * (1 << scale);
774 if (code == 0) {
775 scale--;
776 } else if (code == 127 || code == -128) {
777 scale++;
778 }
779 scale = av_clip(scale, 0, 8);
780 sample = av_clip_int16(sample);
781
782 c->predictor = sample;
783 c->step = scale;
784
785 return sample;
786}
787
788static inline int16_t adpcm_zork_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
789{
790 int16_t index = c->step_index;
791 uint32_t lookup_sample = ff_adpcm_step_table[index];
792 int32_t sample = 0;
793
794 if (nibble & 0x40)
795 sample += lookup_sample;
796 if (nibble & 0x20)
797 sample += lookup_sample >> 1;
798 if (nibble & 0x10)
799 sample += lookup_sample >> 2;
800 if (nibble & 0x08)
801 sample += lookup_sample >> 3;
802 if (nibble & 0x04)
803 sample += lookup_sample >> 4;
804 if (nibble & 0x02)
805 sample += lookup_sample >> 5;
806 if (nibble & 0x01)
807 sample += lookup_sample >> 6;
808 if (nibble & 0x80)
809 sample = -sample;
810
811 sample += c->predictor;
812 sample = av_clip_int16(sample);
813
814 index += zork_index_table[(nibble >> 4) & 7];
815 index = av_clip(index, 0, 88);
816
817 c->predictor = sample;
818 c->step_index = index;
819
820 return sample;
821}
822
823static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
824 const uint8_t *in, ADPCMChannelStatus *left,
825 ADPCMChannelStatus *right, int channels, int sample_offset)
826{
827 int i, j;
828 int shift,filter,f0,f1;
829 int s_1,s_2;
830 int d,s,t;
831
832 out0 += sample_offset;
833 if (channels == 1)
834 out1 = out0 + 28;
835 else
836 out1 += sample_offset;
837
838 for(i=0;i<4;i++) {
839 shift = 12 - (in[4+i*2] & 15);
840 filter = in[4+i*2] >> 4;
841 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
842 avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
843 filter=0;
844 }
845 if (shift < 0) {
846 avpriv_request_sample(avctx, "unknown XA-ADPCM shift %d", shift);
847 shift = 0;
848 }
849 f0 = xa_adpcm_table[filter][0];
850 f1 = xa_adpcm_table[filter][1];
851
852 s_1 = left->sample1;
853 s_2 = left->sample2;
854
855 for(j=0;j<28;j++) {
856 d = in[16+i+j*4];
857
858 t = sign_extend(d, 4);
859 s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
860 s_2 = s_1;
861 s_1 = av_clip_int16(s);
862 out0[j] = s_1;
863 }
864
865 if (channels == 2) {
866 left->sample1 = s_1;
867 left->sample2 = s_2;
868 s_1 = right->sample1;
869 s_2 = right->sample2;
870 }
871
872 shift = 12 - (in[5+i*2] & 15);
873 filter = in[5+i*2] >> 4;
874 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table) || shift < 0) {
875 avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
876 filter=0;
877 }
878 if (shift < 0) {
879 avpriv_request_sample(avctx, "unknown XA-ADPCM shift %d", shift);
880 shift = 0;
881 }
882
883 f0 = xa_adpcm_table[filter][0];
884 f1 = xa_adpcm_table[filter][1];
885
886 for(j=0;j<28;j++) {
887 d = in[16+i+j*4];
888
889 t = sign_extend(d >> 4, 4);
890 s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
891 s_2 = s_1;
892 s_1 = av_clip_int16(s);
893 out1[j] = s_1;
894 }
895
896 if (channels == 2) {
897 right->sample1 = s_1;
898 right->sample2 = s_2;
899 } else {
900 left->sample1 = s_1;
901 left->sample2 = s_2;
902 }
903
904 out0 += 28 * (3 - channels);
905 out1 += 28 * (3 - channels);
906 }
907
908 return 0;
909}
910
911static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
912{
913 ADPCMDecodeContext *c = avctx->priv_data;
914 GetBitContext gb;
915 const int8_t *table;
916 int channels = avctx->ch_layout.nb_channels;
917 int k0, signmask, nb_bits, count;
918 int size = buf_size*8;
919 int i;
920
921 init_get_bits(&gb, buf, size);
922
923 //read bits & initial values
924 nb_bits = get_bits(&gb, 2)+2;
925 table = swf_index_tables[nb_bits-2];
926 k0 = 1 << (nb_bits-2);
927 signmask = 1 << (nb_bits-1);
928
929 while (get_bits_count(&gb) <= size - 22 * channels) {
930 for (i = 0; i < channels; i++) {
931 *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
932 c->status[i].step_index = get_bits(&gb, 6);
933 }
934
935 for (count = 0; get_bits_count(&gb) <= size - nb_bits * channels && count < 4095; count++) {
936 int i;
937
938 for (i = 0; i < channels; i++) {
939 // similar to IMA adpcm
940 int delta = get_bits(&gb, nb_bits);
941 int step = ff_adpcm_step_table[c->status[i].step_index];
942 int vpdiff = 0; // vpdiff = (delta+0.5)*step/4
943 int k = k0;
944
945 do {
946 if (delta & k)
947 vpdiff += step;
948 step >>= 1;
949 k >>= 1;
950 } while(k);
951 vpdiff += step;
952
953 if (delta & signmask)
954 c->status[i].predictor -= vpdiff;
955 else
956 c->status[i].predictor += vpdiff;
957
958 c->status[i].step_index += table[delta & (~signmask)];
959
960 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
961 c->status[i].predictor = av_clip_int16(c->status[i].predictor);
962
963 *samples++ = c->status[i].predictor;
964 }
965 }
966 }
967}
968
969int16_t ff_adpcm_argo_expand_nibble(ADPCMChannelStatus *cs, int nibble, int shift, int flag)
970{
971 int sample = sign_extend(nibble, 4) * (1 << shift);
972
973 if (flag)
974 sample += (8 * cs->sample1) - (4 * cs->sample2);
975 else
976 sample += 4 * cs->sample1;
977
978 sample = av_clip_int16(sample >> 2);
979
980 cs->sample2 = cs->sample1;
981 cs->sample1 = sample;
982
983 return sample;
984}
985
986static int adpcm_sanyo_expand3(ADPCMChannelStatus *c, int bits)
987{
988 int sign, delta, add;
989
990 sign = bits & 4;
991 if (sign)
992 delta = 4 - (bits & 3);
993 else
994 delta = bits;
995
996 switch (delta) {
997 case 0:
998 add = 0;
999 c->step = (3 * c->step) >> 2;
1000 break;
1001 case 1:
1002 add = c->step;
1003 c->step = (4 * c->step - (c->step >> 1)) >> 2;
1004 break;
1005 case 2:
1006 add = 2 * c->step;
1007 c->step = ((c->step >> 1) + add) >> 1;
1008 break;
1009 case 3:
1010 add = 4 * c->step - (c->step >> 1);
1011 c->step = 2 * c->step;
1012 break;
1013 case 4:
1014 add = (11 * c->step) >> 1;
1015 c->step = 3 * c->step;
1016 break;
1017 default:
1018 av_unreachable("There are cases for all control paths when bits is 3-bit");
1019 }
1020
1021 if (sign)
1022 add = -add;
1023
1024 c->predictor = av_clip_int16(c->predictor + add);
1025 c->step = av_clip(c->step, 1, 7281);
1026 return c->predictor;
1027}
1028
1029static int adpcm_sanyo_expand4(ADPCMChannelStatus *c, int bits)
1030{
1031 int sign, delta, add;
1032
1033 sign = bits & 8;
1034 if (sign)
1035 delta = 8 - (bits & 7);
1036 else
1037 delta = bits;
1038
1039 switch (delta) {
1040 case 0:
1041 add = 0;
1042 c->step = (3 * c->step) >> 2;
1043 break;
1044 case 1:
1045 add = c->step;
1046 c->step = (3 * c->step) >> 2;
1047 break;
1048 case 2:
1049 add = 2 * c->step;
1050 break;
1051 case 3:
1052 add = 3 * c->step;
1053 break;
1054 case 4:
1055 add = 4 * c->step;
1056 break;
1057 case 5:
1058 add = (11 * c->step) >> 1;
1059 c->step += c->step >> 2;
1060 break;
1061 case 6:
1062 add = (15 * c->step) >> 1;
1063 c->step = 2 * c->step;
1064 break;
1065 case 7:
1066 if (sign)
1067 add = (19 * c->step) >> 1;
1068 else
1069 add = (21 * c->step) >> 1;
1070 c->step = (c->step >> 1) + 2 * c->step;
1071 break;
1072 case 8:
1073 add = (25 * c->step) >> 1;
1074 c->step = 5 * c->step;
1075 break;
1076 default:
1077 av_unreachable("There are cases for all control paths when bits is 4-bit");
1078 }
1079
1080 if (sign)
1081 add = -add;
1082
1083 c->predictor = av_clip_int16(c->predictor + add);
1084 c->step = av_clip(c->step, 1, 2621);
1085 return c->predictor;
1086}
1087
1088static int adpcm_sanyo_expand5(ADPCMChannelStatus *c, int bits)
1089{
1090 int sign, delta, add;
1091
1092 sign = bits & 0x10;
1093 if (sign)
1094 delta = 16 - (bits & 0xF);
1095 else
1096 delta = bits;
1097
1098 add = delta * c->step;
1099 switch (delta) {
1100 case 0:
1101 c->step += (c->step >> 2) - (c->step >> 1);
1102 break;
1103 case 1:
1104 case 2:
1105 case 3:
1106 c->step += (c->step >> 3) - (c->step >> 2);
1107 break;
1108 case 4:
1109 case 5:
1110 c->step += (c->step >> 4) - (c->step >> 3);
1111 break;
1112 case 6:
1113 break;
1114 case 7:
1115 c->step += c->step >> 3;
1116 break;
1117 case 8:
1118 c->step += c->step >> 2;
1119 break;
1120 case 9:
1121 c->step += c->step >> 1;
1122 break;
1123 case 10:
1124 c->step = 2 * c->step - (c->step >> 3);
1125 break;
1126 case 11:
1127 c->step = 2 * c->step + (c->step >> 3);
1128 break;
1129 case 12:
1130 c->step = 2 * c->step + (c->step >> 1) - (c->step >> 3);
1131 break;
1132 case 13:
1133 c->step = 3 * c->step - (c->step >> 2);
1134 break;
1135 case 14:
1136 c->step *= 3;
1137 break;
1138 case 15:
1139 case 16:
1140 c->step = (7 * c->step) >> 1;
1141 break;
1142 }
1143
1144 if (sign)
1145 add = -add;
1146
1147 c->predictor = av_clip_int16(c->predictor + add);
1148 c->step = av_clip(c->step, 1, 1024);
1149 return c->predictor;
1150}
1151
1152/**
1153 * Get the number of samples (per channel) that will be decoded from the packet.
1154 * In one case, this is actually the maximum number of samples possible to
1155 * decode with the given buf_size.
1156 *
1157 * @param[out] coded_samples set to the number of samples as coded in the
1158 * packet, or 0 if the codec does not encode the
1159 * number of samples in each frame.
1160 * @param[out] approx_nb_samples set to non-zero if the number of samples
1161 * returned is an approximation.
1162 */
1163static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
1164 int buf_size, int *coded_samples, int *approx_nb_samples)
1165{
1166 ADPCMDecodeContext *s = avctx->priv_data;
1167 int nb_samples = 0;
1168 int ch = avctx->ch_layout.nb_channels;
1169 int has_coded_samples = 0;
1170 int header_size;
1171
1172 *coded_samples = 0;
1173 *approx_nb_samples = 0;
1174
1175 if(ch <= 0)
1176 return 0;
1177 if (buf_size > INT_MAX / 14)
1178 return 0;
1179
1180 switch (avctx->codec->id) {
1181 /* constant, only check buf_size */
1182 case AV_CODEC_ID_ADPCM_EA_XAS:
1183 if (buf_size < 76 * ch)
1184 return 0;
1185 nb_samples = 128;
1186 break;
1187 case AV_CODEC_ID_ADPCM_IMA_QT:
1188 if (buf_size < 34 * ch)
1189 return 0;
1190 nb_samples = 64;
1191 break;
1192 case AV_CODEC_ID_ADPCM_N64:
1193 nb_samples = (buf_size / 9) * 16;
1194 break;
1195 /* simple 4-bit adpcm */
1196 case AV_CODEC_ID_ADPCM_CT:
1197 case AV_CODEC_ID_ADPCM_IMA_APC:
1198 case AV_CODEC_ID_ADPCM_IMA_CUNNING:
1199 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
1200 case AV_CODEC_ID_ADPCM_IMA_ESCAPE:
1201 case AV_CODEC_ID_ADPCM_IMA_OKI:
1202 case AV_CODEC_ID_ADPCM_IMA_WS:
1203 case AV_CODEC_ID_ADPCM_YAMAHA:
1204 case AV_CODEC_ID_ADPCM_AICA:
1205 case AV_CODEC_ID_ADPCM_IMA_SSI:
1206 case AV_CODEC_ID_ADPCM_IMA_APM:
1207 case AV_CODEC_ID_ADPCM_IMA_ALP:
1208 case AV_CODEC_ID_ADPCM_IMA_MTF:
1209 nb_samples = buf_size * 2 / ch;
1210 break;
1211 }
1212 if (nb_samples)
1213 return nb_samples;
1214
1215 /* simple 4-bit adpcm, with header */
1216 header_size = 0;
1217 switch (avctx->codec->id) {
1218 case AV_CODEC_ID_ADPCM_4XM:
1219 case AV_CODEC_ID_ADPCM_AGM:
1220 case AV_CODEC_ID_ADPCM_IMA_ACORN:
1221 case AV_CODEC_ID_ADPCM_IMA_DAT4:
1222 case AV_CODEC_ID_ADPCM_IMA_MOFLEX:
1223 case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;
1224 case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4 * ch; break;
1225 }
1226 if (header_size > 0)
1227 return (buf_size - header_size) * 2 / ch;
1228
1229 /* more complex formats */
1230 switch (avctx->codec->id) {
1231 case AV_CODEC_ID_ADPCM_IMA_AMV:
1232 bytestream2_skip(gb, 4);
1233 has_coded_samples = 1;
1234 *coded_samples = bytestream2_get_le32u(gb);
1235 nb_samples = FFMIN((buf_size - 8) * 2, *coded_samples);
1236 bytestream2_seek(gb, -8, SEEK_CUR);
1237 break;
1238 case AV_CODEC_ID_ADPCM_EA:
1239 /* Stereo is 30 bytes per block */
1240 /* Mono is 15 bytes per block */
1241 has_coded_samples = 1;
1242 *coded_samples = bytestream2_get_le32(gb);
1243 *coded_samples -= *coded_samples % 28;
1244 nb_samples = (buf_size - 12) / (ch == 2 ? 30 : 15) * 28;
1245 break;
1246 case AV_CODEC_ID_ADPCM_IMA_HVQM2:
1247 nb_samples = ((bytestream2_peek_be64(gb) >> 16) & 0xFFFF);
1248 break;
1249 case AV_CODEC_ID_ADPCM_IMA_HVQM4:
1250 {
1251 int frame_format = bytestream2_get_be16(gb);
1252 int skip = 6;
1253
1254 if (frame_format == 1)
1255 skip += 2 * ch;
1256 if (frame_format == 3)
1257 skip += 3 * ch;
1258
1259 nb_samples = (buf_size - skip) * 2 / ch;
1260 bytestream2_seek(gb, 0, SEEK_SET);
1261 }
1262 break;
1263 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
1264 has_coded_samples = 1;
1265 *coded_samples = bytestream2_get_le32(gb);
1266 nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
1267 break;
1268 case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
1269 nb_samples = (buf_size - ch) / ch * 2;
1270 break;
1271 case AV_CODEC_ID_ADPCM_EA_R1:
1272 case AV_CODEC_ID_ADPCM_EA_R2:
1273 case AV_CODEC_ID_ADPCM_EA_R3:
1274 /* maximum number of samples */
1275 /* has internal offsets and a per-frame switch to signal raw 16-bit */
1276 has_coded_samples = 1;
1277 switch (avctx->codec->id) {
1278 case AV_CODEC_ID_ADPCM_EA_R1:
1279 header_size = 4 + 9 * ch;
1280 *coded_samples = bytestream2_get_le32(gb);
1281 break;
1282 case AV_CODEC_ID_ADPCM_EA_R2:
1283 header_size = 4 + 5 * ch;
1284 *coded_samples = bytestream2_get_le32(gb);
1285 break;
1286 case AV_CODEC_ID_ADPCM_EA_R3:
1287 header_size = 4 + 5 * ch;
1288 *coded_samples = bytestream2_get_be32(gb);
1289 break;
1290 }
1291 *coded_samples -= *coded_samples % 28;
1292 nb_samples = (buf_size - header_size) * 2 / ch;
1293 nb_samples -= nb_samples % 28;
1294 *approx_nb_samples = 1;
1295 break;
1296 case AV_CODEC_ID_ADPCM_IMA_DK3:
1297 if (avctx->block_align > 0)
1298 buf_size = FFMIN(buf_size, avctx->block_align);
1299 nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
1300 break;
1301 case AV_CODEC_ID_ADPCM_IMA_DK4:
1302 if (avctx->block_align > 0)
1303 buf_size = FFMIN(buf_size, avctx->block_align);
1304 if (buf_size < 4 * ch)
1305 return AVERROR_INVALIDDATA;
1306 nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
1307 break;
1308 case AV_CODEC_ID_ADPCM_IMA_RAD:
1309 if (avctx->block_align > 0)
1310 buf_size = FFMIN(buf_size, avctx->block_align);
1311 nb_samples = (buf_size - 4 * ch) * 2 / ch;
1312 break;
1313 case AV_CODEC_ID_ADPCM_IMA_PDA:
1314 if (avctx->block_align > 0)
1315 buf_size = FFMIN(buf_size, avctx->block_align);
1316 nb_samples = (buf_size - 4 * ch) * 2 / ch;
1317 break;
1318 case AV_CODEC_ID_ADPCM_IMA_MAGIX:
1319 if (avctx->block_align > 0)
1320 buf_size = FFMIN(buf_size, avctx->block_align);
1321 nb_samples = (buf_size - 4 * ch) * 2 / ch;
1322 if (ch == 1) {
1323 avpriv_request_sample(avctx, "mono ADPCM Magix");
1324 return AVERROR_PATCHWELCOME;
1325 }
1326 break;
1327 CASE(ADPCM_IMA_WAV,
1328 int bsize = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
1329 int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
1330 if (avctx->block_align > 0)
1331 buf_size = FFMIN(buf_size, avctx->block_align);
1332 if (buf_size < 4 * ch)
1333 return AVERROR_INVALIDDATA;
1334 nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;
1335 ) /* End of CASE */
1336 CASE(ADPCM_IMA_XBOX,
1337 int bsize = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
1338 int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
1339 if (avctx->block_align > 0)
1340 buf_size = FFMIN(buf_size, avctx->block_align);
1341 if (buf_size < 4 * ch)
1342 return AVERROR_INVALIDDATA;
1343 nb_samples = (buf_size - 4 * ch) / (bsize * ch) * bsamples + 1;
1344 ) /* End of CASE */
1345 case AV_CODEC_ID_ADPCM_MS:
1346 if (avctx->block_align > 0)
1347 buf_size = FFMIN(buf_size, avctx->block_align);
1348 nb_samples = (buf_size - 6 * ch) * 2 / ch;
1349 break;
1350 case AV_CODEC_ID_ADPCM_MTAF:
1351 if (avctx->block_align > 0)
1352 buf_size = FFMIN(buf_size, avctx->block_align);
1353 nb_samples = (buf_size - 16 * (ch / 2)) * 2 / ch;
1354 break;
1355 case AV_CODEC_ID_ADPCM_SBPRO_2:
1356 case AV_CODEC_ID_ADPCM_SBPRO_3:
1357 case AV_CODEC_ID_ADPCM_SBPRO_4:
1358 {
1359 int samples_per_byte;
1360 switch (avctx->codec->id) {
1361 case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
1362 case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
1363 case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
1364 }
1365 if (!s->status[0].step_index) {
1366 if (buf_size < ch)
1367 return AVERROR_INVALIDDATA;
1368 nb_samples++;
1369 buf_size -= ch;
1370 }
1371 nb_samples += buf_size * samples_per_byte / ch;
1372 break;
1373 }
1374 case AV_CODEC_ID_ADPCM_SWF:
1375 {
1376 int buf_bits = buf_size * 8 - 2;
1377 int nbits = (bytestream2_get_byte(gb) >> 6) + 2;
1378 int block_hdr_size = 22 * ch;
1379 int block_size = block_hdr_size + nbits * ch * 4095;
1380 int nblocks = buf_bits / block_size;
1381 int bits_left = buf_bits - nblocks * block_size;
1382 nb_samples = nblocks * 4096;
1383 if (bits_left >= block_hdr_size)
1384 nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
1385 break;
1386 }
1387 case AV_CODEC_ID_ADPCM_THP:
1388 case AV_CODEC_ID_ADPCM_THP_LE:
1389 if (avctx->extradata) {
1390 nb_samples = buf_size * 14 / (8 * ch);
1391 break;
1392 }
1393 has_coded_samples = 1;
1394 bytestream2_skip(gb, 4); // channel size
1395 *coded_samples = (avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE) ?
1396 bytestream2_get_le32(gb) :
1397 bytestream2_get_be32(gb);
1398 buf_size -= 8 + 36 * ch;
1399 buf_size /= ch;
1400 nb_samples = buf_size / 8 * 14;
1401 if (buf_size % 8 > 1)
1402 nb_samples += (buf_size % 8 - 1) * 2;
1403 *approx_nb_samples = 1;
1404 break;
1405 case AV_CODEC_ID_ADPCM_AFC:
1406 nb_samples = buf_size / (9 * ch) * 16;
1407 break;
1408 case AV_CODEC_ID_ADPCM_XA:
1409 nb_samples = (buf_size / 128) * 224 / ch;
1410 break;
1411 case AV_CODEC_ID_ADPCM_XMD:
1412 nb_samples = buf_size / (21 * ch) * 32;
1413 break;
1414 case AV_CODEC_ID_ADPCM_DTK:
1415 case AV_CODEC_ID_ADPCM_PSX:
1416 nb_samples = buf_size / (16 * ch) * 28;
1417 break;
1418 case AV_CODEC_ID_ADPCM_PSXC:
1419 nb_samples = ((buf_size - 1) / ch) * 2;
1420 break;
1421 case AV_CODEC_ID_ADPCM_ARGO:
1422 nb_samples = buf_size / avctx->block_align * 32;
1423 break;
1424 case AV_CODEC_ID_ADPCM_CIRCUS:
1425 case AV_CODEC_ID_ADPCM_ZORK:
1426 nb_samples = buf_size / ch;
1427 break;
1428 case AV_CODEC_ID_ADPCM_SANYO:
1429 if (!avctx->extradata || avctx->extradata_size != 2)
1430 return AVERROR_INVALIDDATA;
1431 nb_samples = AV_RL16(avctx->extradata);
1432 break;
1433 }
1434
1435 /* validate coded sample count */
1436 if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
1437 return AVERROR_INVALIDDATA;
1438
1439 return nb_samples;
1440}
1441
1442static int adpcm_decode_frame(AVCodecContext *avctx, AVFrame *frame,
1443 int *got_frame_ptr, AVPacket *avpkt)
1444{
1445 const uint8_t *buf = avpkt->data;
1446 int buf_size = avpkt->size;
1447 ADPCMDecodeContext *c = avctx->priv_data;
1448 int channels = avctx->ch_layout.nb_channels;
1449 int16_t *samples;
1450 int16_t **samples_p;
1451 int st; /* stereo */
1452 int nb_samples, coded_samples, approx_nb_samples, ret;
1453 GetByteContext gb;
1454
1455 bytestream2_init(&gb, buf, buf_size);
1456 nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);
1457 if (nb_samples <= 0) {
1458 av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
1459 return AVERROR_INVALIDDATA;
1460 }
1461
1462 /* get output buffer */
1463 frame->nb_samples = nb_samples;
1464 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1465 return ret;
1466 samples = (int16_t *)frame->data[0];
1467 samples_p = (int16_t **)frame->extended_data;
1468
1469 /* use coded_samples when applicable */
1470 /* it is always <= nb_samples, so the output buffer will be large enough */
1471 if (coded_samples) {
1472 if (!approx_nb_samples && coded_samples != nb_samples)
1473 av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
1474 frame->nb_samples = nb_samples = coded_samples;
1475 }
1476
1477 st = channels == 2 ? 1 : 0;
1478
1479 switch(avctx->codec->id) {
1480 CASE(ADPCM_IMA_QT,
1481 /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
1482 Channel data is interleaved per-chunk. */
1483 for (int channel = 0; channel < channels; channel++) {
1484 ADPCMChannelStatus *cs = &c->status[channel];
1485 int predictor;
1486 int step_index;
1487 /* (pppppp) (piiiiiii) */
1488
1489 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
1490 predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
1491 step_index = predictor & 0x7F;
1492 predictor &= ~0x7F;
1493
1494 if (cs->step_index == step_index) {
1495 int diff = predictor - cs->predictor;
1496 if (diff < 0)
1497 diff = - diff;
1498 if (diff > 0x7f)
1499 goto update;
1500 } else {
1501 update:
1502 cs->step_index = step_index;
1503 cs->predictor = predictor;
1504 }
1505
1506 if (cs->step_index > 88u){
1507 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1508 channel, cs->step_index);
1509 return AVERROR_INVALIDDATA;
1510 }
1511
1512 samples = samples_p[channel];
1513
1514 for (int m = 0; m < 64; m += 2) {
1515 int byte = bytestream2_get_byteu(&gb);
1516 samples[m ] = ff_adpcm_ima_qt_expand_nibble(cs, byte & 0x0F);
1517 samples[m + 1] = ff_adpcm_ima_qt_expand_nibble(cs, byte >> 4 );
1518 }
1519 }
1520 ) /* End of CASE */
1521 CASE(ADPCM_IMA_WAV,
1522 for (int i = 0; i < channels; i++) {
1523 ADPCMChannelStatus *cs = &c->status[i];
1524 cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
1525
1526 cs->step_index = bytestream2_get_byteu(&gb);
1527 bytestream2_skipu(&gb, 1);
1528 if (cs->step_index > 88u){
1529 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1530 i, cs->step_index);
1531 return AVERROR_INVALIDDATA;
1532 }
1533 }
1534
1535 if (avctx->bits_per_coded_sample != 4) {
1536 int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
1537 int block_size = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
1538 uint8_t temp[20 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
1539 GetBitContext g;
1540
1541 for (int n = 0; n < (nb_samples - 1) / samples_per_block; n++) {
1542 for (int i = 0; i < channels; i++) {
1543 ADPCMChannelStatus *cs = &c->status[i];
1544 samples = &samples_p[i][1 + n * samples_per_block];
1545 for (int j = 0; j < block_size; j++) {
1546 temp[j] = buf[4 * channels + block_size * n * channels +
1547 (j % 4) + (j / 4) * (channels * 4) + i * 4];
1548 }
1549 ret = init_get_bits8(&g, (const uint8_t *)&temp, block_size);
1550 if (ret < 0)
1551 return ret;
1552 for (int m = 0; m < samples_per_block; m++) {
1553 samples[m] = adpcm_ima_wav_expand_nibble(cs, &g,
1554 avctx->bits_per_coded_sample);
1555 }
1556 }
1557 }
1558 bytestream2_skip(&gb, avctx->block_align - channels * 4);
1559 } else {
1560 for (int n = 0; n < (nb_samples - 1) / 8; n++) {
1561 for (int i = 0; i < channels; i++) {
1562 ADPCMChannelStatus *cs = &c->status[i];
1563 samples = &samples_p[i][1 + n * 8];
1564 for (int m = 0; m < 8; m += 2) {
1565 int v = bytestream2_get_byteu(&gb);
1566 samples[m ] = ff_adpcm_ima_qt_expand_nibble(cs, v & 0x0F);
1567 samples[m + 1] = ff_adpcm_ima_qt_expand_nibble(cs, v >> 4);
1568 }
1569 }
1570 }
1571 }
1572 ) /* End of CASE */
1573 CASE(ADPCM_IMA_XBOX,
1574 for (int i = 0; i < channels; i++) {
1575 ADPCMChannelStatus *cs = &c->status[i];
1576 cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
1577
1578 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1579 if (cs->step_index > 88u) {
1580 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1581 i, cs->step_index);
1582 return AVERROR_INVALIDDATA;
1583 }
1584 }
1585
1586 for (int n = 0; n < (nb_samples-1) / 8; n++) {
1587 for (int i = 0; i < channels; i++) {
1588 ADPCMChannelStatus *cs = &c->status[i];
1589 samples = &samples_p[i][1 + n * 8];
1590 for (int m = 0; m < 8; m += 2) {
1591 int v = bytestream2_get_byteu(&gb);
1592 samples[m ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1593 samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
1594 }
1595 }
1596 }
1597 frame->nb_samples--;
1598 ) /* End of CASE */
1599 CASE(ADPCM_4XM,
1600 for (int i = 0; i < channels; i++)
1601 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1602
1603 for (int i = 0; i < channels; i++) {
1604 c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1605 if (c->status[i].step_index > 88u) {
1606 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1607 i, c->status[i].step_index);
1608 return AVERROR_INVALIDDATA;
1609 }
1610 }
1611
1612 for (int i = 0; i < channels; i++) {
1613 ADPCMChannelStatus *cs = &c->status[i];
1614 samples = (int16_t *)frame->data[i];
1615 for (int n = nb_samples >> 1; n > 0; n--) {
1616 int v = bytestream2_get_byteu(&gb);
1617 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
1618 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 4);
1619 }
1620 }
1621 ) /* End of CASE */
1622 CASE(ADPCM_AGM,
1623 for (int i = 0; i < channels; i++)
1624 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1625 for (int i = 0; i < channels; i++)
1626 c->status[i].step = sign_extend(bytestream2_get_le16u(&gb), 16);
1627
1628 for (int n = 0; n < nb_samples >> (1 - st); n++) {
1629 int v = bytestream2_get_byteu(&gb);
1630 *samples++ = adpcm_agm_expand_nibble(&c->status[0], v & 0xF);
1631 *samples++ = adpcm_agm_expand_nibble(&c->status[st], v >> 4 );
1632 }
1633 ) /* End of CASE */
1634 CASE(ADPCM_MS,
1635 int block_predictor;
1636
1637 if (avctx->ch_layout.nb_channels > 2) {
1638 for (int channel = 0; channel < avctx->ch_layout.nb_channels; channel++) {
1639 samples = samples_p[channel];
1640 block_predictor = bytestream2_get_byteu(&gb);
1641 if (block_predictor > 6) {
1642 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[%d] = %d\n",
1643 channel, block_predictor);
1644 return AVERROR_INVALIDDATA;
1645 }
1646 c->status[channel].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1647 c->status[channel].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1648 c->status[channel].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1649 c->status[channel].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1650 c->status[channel].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1651 *samples++ = c->status[channel].sample2;
1652 *samples++ = c->status[channel].sample1;
1653 for (int n = (nb_samples - 2) >> 1; n > 0; n--) {
1654 int byte = bytestream2_get_byteu(&gb);
1655 *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte >> 4 );
1656 *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte & 0x0F);
1657 }
1658 }
1659 } else {
1660 block_predictor = bytestream2_get_byteu(&gb);
1661 if (block_predictor > 6) {
1662 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
1663 block_predictor);
1664 return AVERROR_INVALIDDATA;
1665 }
1666 c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1667 c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1668 if (st) {
1669 block_predictor = bytestream2_get_byteu(&gb);
1670 if (block_predictor > 6) {
1671 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
1672 block_predictor);
1673 return AVERROR_INVALIDDATA;
1674 }
1675 c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1676 c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1677 }
1678 c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1679 if (st){
1680 c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1681 }
1682
1683 c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1684 if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1685 c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1686 if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1687
1688 *samples++ = c->status[0].sample2;
1689 if (st) *samples++ = c->status[1].sample2;
1690 *samples++ = c->status[0].sample1;
1691 if (st) *samples++ = c->status[1].sample1;
1692 for (int n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
1693 int byte = bytestream2_get_byteu(&gb);
1694 *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4 );
1695 *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
1696 }
1697 }
1698 ) /* End of CASE */
1699 CASE(ADPCM_MTAF,
1700 for (int channel = 0; channel < channels; channel += 2) {
1701 bytestream2_skipu(&gb, 4);
1702 c->status[channel ].step = bytestream2_get_le16u(&gb) & 0x1f;
1703 c->status[channel + 1].step = bytestream2_get_le16u(&gb) & 0x1f;
1704 c->status[channel ].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1705 bytestream2_skipu(&gb, 2);
1706 c->status[channel + 1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1707 bytestream2_skipu(&gb, 2);
1708 for (int n = 0; n < nb_samples; n += 2) {
1709 int v = bytestream2_get_byteu(&gb);
1710 samples_p[channel][n ] = adpcm_mtaf_expand_nibble(&c->status[channel], v & 0x0F);
1711 samples_p[channel][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel], v >> 4 );
1712 }
1713 for (int n = 0; n < nb_samples; n += 2) {
1714 int v = bytestream2_get_byteu(&gb);
1715 samples_p[channel + 1][n ] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v & 0x0F);
1716 samples_p[channel + 1][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v >> 4 );
1717 }
1718 }
1719 ) /* End of CASE */
1720 CASE(ADPCM_IMA_DK4,
1721 for (int channel = 0; channel < channels; channel++) {
1722 ADPCMChannelStatus *cs = &c->status[channel];
1723 cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
1724 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1725 if (cs->step_index > 88u){
1726 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1727 channel, cs->step_index);
1728 return AVERROR_INVALIDDATA;
1729 }
1730 }
1731 for (int n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
1732 int v = bytestream2_get_byteu(&gb);
1733 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3);
1734 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1735 }
1736 ) /* End of CASE */
1737
1738 /* DK3 ADPCM support macro */
1739#define DK3_GET_NEXT_NIBBLE() \
1740 if (decode_top_nibble_next) { \
1741 nibble = last_byte >> 4; \
1742 decode_top_nibble_next = 0; \
1743 } else { \
1744 last_byte = bytestream2_get_byteu(&gb); \
1745 nibble = last_byte & 0x0F; \
1746 decode_top_nibble_next = 1; \
1747 }
1748 CASE(ADPCM_IMA_DK3,
1749 int last_byte = 0;
1750 int nibble;
1751 int decode_top_nibble_next = 0;
1752 int diff_channel;
1753 const int16_t *samples_end = samples + channels * nb_samples;
1754
1755 bytestream2_skipu(&gb, 10);
1756 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1757 c->status[1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1758 c->status[0].step_index = bytestream2_get_byteu(&gb);
1759 c->status[1].step_index = bytestream2_get_byteu(&gb);
1760 if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
1761 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
1762 c->status[0].step_index, c->status[1].step_index);
1763 return AVERROR_INVALIDDATA;
1764 }
1765 /* sign extend the predictors */
1766 diff_channel = c->status[1].predictor;
1767
1768 while (samples < samples_end) {
1769
1770 /* for this algorithm, c->status[0] is the sum channel and
1771 * c->status[1] is the diff channel */
1772
1773 /* process the first predictor of the sum channel */
1774 DK3_GET_NEXT_NIBBLE();
1775 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1776
1777 /* process the diff channel predictor */
1778 DK3_GET_NEXT_NIBBLE();
1779 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
1780
1781 /* process the first pair of stereo PCM samples */
1782 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1783 *samples++ = c->status[0].predictor + c->status[1].predictor;
1784 *samples++ = c->status[0].predictor - c->status[1].predictor;
1785
1786 /* process the second predictor of the sum channel */
1787 DK3_GET_NEXT_NIBBLE();
1788 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1789
1790 /* process the second pair of stereo PCM samples */
1791 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1792 *samples++ = c->status[0].predictor + c->status[1].predictor;
1793 *samples++ = c->status[0].predictor - c->status[1].predictor;
1794 }
1795
1796 if ((bytestream2_tell(&gb) & 1))
1797 bytestream2_skip(&gb, 1);
1798 ) /* End of CASE */
1799 CASE(ADPCM_IMA_MAGIX,
1800 for (int channel = 0; channel < channels; channel++) {
1801 ADPCMChannelStatus *cs = &c->status[channel];
1802 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1803 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1804 if (cs->step_index > 88u){
1805 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1806 channel, cs->step_index);
1807 return AVERROR_INVALIDDATA;
1808 }
1809 }
1810
1811 for (int m = 0; m < channels*nb_samples/16; m ++) {
1812 uint32_t v0 = bytestream2_get_le32u(&gb);
1813 uint32_t v1 = bytestream2_get_le32u(&gb);
1814
1815 for (int n = 8; n > 0; n--, v0 >>= 4, v1 >>= 4, samples += 2) {
1816 samples[0] = adpcm_ima_expand_nibble(&c->status[0], v0 & 15, 3);
1817 samples[1] = adpcm_ima_expand_nibble(&c->status[1], v1 & 15, 3);
1818 }
1819 }
1820 ) /* End of CASE */
1821 CASE(ADPCM_IMA_ISS,
1822 for (int channel = 0; channel < channels; channel++) {
1823 ADPCMChannelStatus *cs = &c->status[channel];
1824 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1825 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1826 if (cs->step_index > 88u){
1827 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1828 channel, cs->step_index);
1829 return AVERROR_INVALIDDATA;
1830 }
1831 }
1832
1833 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1834 int v1, v2;
1835 int v = bytestream2_get_byteu(&gb);
1836 /* nibbles are swapped for mono */
1837 if (st) {
1838 v1 = v >> 4;
1839 v2 = v & 0x0F;
1840 } else {
1841 v2 = v >> 4;
1842 v1 = v & 0x0F;
1843 }
1844 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
1845 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
1846 }
1847 ) /* End of CASE */
1848 CASE(ADPCM_IMA_MOFLEX,
1849 for (int channel = 0; channel < channels; channel++) {
1850 ADPCMChannelStatus *cs = &c->status[channel];
1851 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1852 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1853 if (cs->step_index > 88u){
1854 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1855 channel, cs->step_index);
1856 return AVERROR_INVALIDDATA;
1857 }
1858 }
1859
1860 for (int subframe = 0; subframe < nb_samples / 256; subframe++) {
1861 for (int channel = 0; channel < channels; channel++) {
1862 samples = samples_p[channel] + 256 * subframe;
1863 for (int n = 0; n < 256; n += 2) {
1864 int v = bytestream2_get_byteu(&gb);
1865 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1866 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1867 }
1868 }
1869 }
1870 ) /* End of CASE */
1871 CASE(ADPCM_IMA_DAT4,
1872 for (int channel = 0; channel < channels; channel++) {
1873 ADPCMChannelStatus *cs = &c->status[channel];
1874 samples = samples_p[channel];
1875 bytestream2_skip(&gb, 4);
1876 for (int n = 0; n < nb_samples; n += 2) {
1877 int v = bytestream2_get_byteu(&gb);
1878 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
1879 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1880 }
1881 }
1882 ) /* End of CASE */
1883 CASE(ADPCM_IMA_APC,
1884 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1885 int v = bytestream2_get_byteu(&gb);
1886 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
1887 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1888 }
1889 ) /* End of CASE */
1890 CASE(ADPCM_IMA_HVQM2,
1891 int format = bytestream2_get_be16(&gb);
1892
1893 bytestream2_skip(&gb, 4);
1894 decode_adpcm_ima_hvqm2(avctx, samples, nb_samples, format, &gb);
1895 ) /* End of CASE */
1896 CASE(ADPCM_IMA_HVQM4,
1897 int format = bytestream2_get_be16(&gb);
1898
1899 bytestream2_skip(&gb, 4);
1900 decode_adpcm_ima_hvqm4(avctx, samples, nb_samples, format, &gb);
1901 ) /* End of CASE */
1902 CASE(ADPCM_IMA_SSI,
1903 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1904 int v = bytestream2_get_byteu(&gb);
1905 *samples++ = ff_adpcm_ima_qt_expand_nibble(&c->status[0], v >> 4 );
1906 *samples++ = ff_adpcm_ima_qt_expand_nibble(&c->status[st], v & 0x0F);
1907 }
1908 ) /* End of CASE */
1909 CASE(ADPCM_IMA_APM,
1910 for (int n = nb_samples / 2; n > 0; n--) {
1911 for (int channel = 0; channel < channels; channel++) {
1912 int v = bytestream2_get_byteu(&gb);
1913 *samples++ = ff_adpcm_ima_qt_expand_nibble(&c->status[channel], v >> 4 );
1914 samples[st] = ff_adpcm_ima_qt_expand_nibble(&c->status[channel], v & 0x0F);
1915 }
1916 samples += channels;
1917 }
1918 ) /* End of CASE */
1919 CASE(ADPCM_IMA_ALP,
1920 for (int n = nb_samples / 2; n > 0; n--) {
1921 for (int channel = 0; channel < channels; channel++) {
1922 int v = bytestream2_get_byteu(&gb);
1923 *samples++ = adpcm_ima_alp_expand_nibble(&c->status[channel], v >> 4 , 2);
1924 samples[st] = adpcm_ima_alp_expand_nibble(&c->status[channel], v & 0x0F, 2);
1925 }
1926 samples += channels;
1927 }
1928 ) /* End of CASE */
1929 CASE(ADPCM_IMA_CUNNING,
1930 for (int channel = 0; channel < channels; channel++) {
1931 int16_t *smp = samples_p[channel];
1932 for (int n = 0; n < nb_samples / 2; n++) {
1933 int v = bytestream2_get_byteu(&gb);
1934 *smp++ = adpcm_ima_cunning_expand_nibble(&c->status[channel], v & 0x0F);
1935 *smp++ = adpcm_ima_cunning_expand_nibble(&c->status[channel], v >> 4);
1936 }
1937 }
1938 ) /* End of CASE */
1939 CASE(ADPCM_IMA_OKI,
1940 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1941 int v = bytestream2_get_byteu(&gb);
1942 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[0], v >> 4 );
1943 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[st], v & 0x0F);
1944 }
1945 ) /* End of CASE */
1946 CASE(ADPCM_IMA_RAD,
1947 for (int channel = 0; channel < channels; channel++) {
1948 ADPCMChannelStatus *cs = &c->status[channel];
1949 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1950 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1951 if (cs->step_index > 88u){
1952 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1953 channel, cs->step_index);
1954 return AVERROR_INVALIDDATA;
1955 }
1956 }
1957 for (int n = 0; n < nb_samples / 2; n++) {
1958 int byte[2];
1959
1960 byte[0] = bytestream2_get_byteu(&gb);
1961 if (st)
1962 byte[1] = bytestream2_get_byteu(&gb);
1963 for (int channel = 0; channel < channels; channel++) {
1964 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] & 0x0F, 3);
1965 }
1966 for (int channel = 0; channel < channels; channel++) {
1967 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] >> 4 , 3);
1968 }
1969 }
1970 ) /* End of CASE */
1971 CASE(ADPCM_IMA_WS,
1972 if (c->vqa_version == 3) {
1973 for (int channel = 0; channel < channels; channel++) {
1974 int16_t *smp = samples_p[channel];
1975
1976 for (int n = nb_samples / 2; n > 0; n--) {
1977 int v = bytestream2_get_byteu(&gb);
1978 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1979 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1980 }
1981 }
1982 } else {
1983 for (int n = nb_samples / 2; n > 0; n--) {
1984 for (int channel = 0; channel < channels; channel++) {
1985 int v = bytestream2_get_byteu(&gb);
1986 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1987 samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1988 }
1989 samples += channels;
1990 }
1991 }
1992 bytestream2_seek(&gb, 0, SEEK_END);
1993 ) /* End of CASE */
1994 CASE(ADPCM_XMD,
1995 int bytes_remaining, block = 0;
1996 while (bytestream2_get_bytes_left(&gb) >= 21 * channels) {
1997 for (int channel = 0; channel < channels; channel++) {
1998 int16_t *out = samples_p[channel] + block * 32;
1999 int16_t history[2];
2000 uint16_t scale;
2001
2002 history[1] = sign_extend(bytestream2_get_le16(&gb), 16);
2003 history[0] = sign_extend(bytestream2_get_le16(&gb), 16);
2004 scale = bytestream2_get_le16(&gb);
2005
2006 out[0] = history[1];
2007 out[1] = history[0];
2008
2009 for (int n = 0; n < 15; n++) {
2010 unsigned byte = bytestream2_get_byte(&gb);
2011 int32_t nibble[2];
2012
2013 nibble[0] = sign_extend(byte & 15, 4);
2014 nibble[1] = sign_extend(byte >> 4, 4);
2015
2016 out[2+n*2] = nibble[0]*scale + ((history[0]*3667 - history[1]*1642) >> 11);
2017 history[1] = history[0];
2018 history[0] = out[2+n*2];
2019
2020 out[2+n*2+1] = nibble[1]*scale + ((history[0]*3667 - history[1]*1642) >> 11);
2021 history[1] = history[0];
2022 history[0] = out[2+n*2+1];
2023 }
2024 }
2025
2026 block++;
2027 }
2028 bytes_remaining = bytestream2_get_bytes_left(&gb);
2029 if (bytes_remaining > 0) {
2030 bytestream2_skip(&gb, bytes_remaining);
2031 }
2032 ) /* End of CASE */
2033 CASE(ADPCM_XA,
2034 int16_t *out0 = samples_p[0];
2035 int16_t *out1 = samples_p[1];
2036 int samples_per_block = 28 * (3 - channels) * 4;
2037 int sample_offset = 0;
2038 int bytes_remaining;
2039 while (bytestream2_get_bytes_left(&gb) >= 128) {
2040 if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
2041 &c->status[0], &c->status[1],
2042 channels, sample_offset)) < 0)
2043 return ret;
2044 bytestream2_skipu(&gb, 128);
2045 sample_offset += samples_per_block;
2046 }
2047 /* Less than a full block of data left, e.g. when reading from
2048 * 2324 byte per sector XA; the remainder is padding */
2049 bytes_remaining = bytestream2_get_bytes_left(&gb);
2050 if (bytes_remaining > 0) {
2051 bytestream2_skip(&gb, bytes_remaining);
2052 }
2053 ) /* End of CASE */
2054 CASE(ADPCM_IMA_ESCAPE,
2055 for (int n = nb_samples >> (1 - st); n > 0; n--) {
2056 int byte = bytestream2_get_byteu(&gb);
2057 *samples++ = adpcm_ima_escape_expand_nibble(&c->status[0], byte >> 4);
2058 *samples++ = adpcm_ima_escape_expand_nibble(&c->status[st], byte & 0xF);
2059 }
2060 ) /* End of CASE */
2061 CASE(ADPCM_IMA_EA_EACS,
2062 for (int i = 0; i <= st; i++) {
2063 c->status[i].step_index = bytestream2_get_le32u(&gb);
2064 if (c->status[i].step_index > 88u) {
2065 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
2066 i, c->status[i].step_index);
2067 return AVERROR_INVALIDDATA;
2068 }
2069 }
2070 for (int i = 0; i <= st; i++) {
2071 c->status[i].predictor = bytestream2_get_le32u(&gb);
2072 if (FFABS((int64_t)c->status[i].predictor) > (1<<16))
2073 return AVERROR_INVALIDDATA;
2074 }
2075
2076 for (int n = nb_samples >> (1 - st); n > 0; n--) {
2077 int byte = bytestream2_get_byteu(&gb);
2078 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 3);
2079 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
2080 }
2081 ) /* End of CASE */
2082 CASE(ADPCM_IMA_EA_SEAD,
2083 for (int n = nb_samples >> (1 - st); n > 0; n--) {
2084 int byte = bytestream2_get_byteu(&gb);
2085 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);
2086 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
2087 }
2088 ) /* End of CASE */
2089 CASE(ADPCM_EA,
2090 int previous_left_sample, previous_right_sample;
2091 int current_left_sample, current_right_sample;
2092 int next_left_sample, next_right_sample;
2093 int coeff1l, coeff2l, coeff1r, coeff2r;
2094 int shift_left, shift_right;
2095
2096 /* Each EA ADPCM frame has a 12-byte header followed by 30-byte (stereo) or 15-byte (mono) pieces,
2097 each coding 28 stereo/mono samples. */
2098
2099 if (channels != 2 && channels != 1)
2100 return AVERROR_INVALIDDATA;
2101
2102 current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
2103 previous_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
2104 current_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
2105 previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
2106
2107 for (int count1 = 0; count1 < nb_samples / 28; count1++) {
2108 int byte = bytestream2_get_byteu(&gb);
2109 coeff1l = ea_adpcm_table[ byte >> 4 ];
2110 coeff2l = ea_adpcm_table[(byte >> 4 ) + 4];
2111 coeff1r = ea_adpcm_table[ byte & 0x0F];
2112 coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];
2113
2114 if (channels == 2){
2115 byte = bytestream2_get_byteu(&gb);
2116 shift_left = 20 - (byte >> 4);
2117 shift_right = 20 - (byte & 0x0F);
2118 } else{
2119 /* Mono packs the shift into the coefficient byte's lower nibble instead */
2120 shift_left = 20 - (byte & 0x0F);
2121 }
2122
2123 for (int count2 = 0; count2 < (channels == 2 ? 28 : 14); count2++) {
2124 byte = bytestream2_get_byteu(&gb);
2125 next_left_sample = sign_extend(byte >> 4, 4) * (1 << shift_left);
2126
2127 next_left_sample = (next_left_sample +
2128 (current_left_sample * coeff1l) +
2129 (previous_left_sample * coeff2l) + 0x80) >> 8;
2130
2131 previous_left_sample = current_left_sample;
2132 current_left_sample = av_clip_int16(next_left_sample);
2133 *samples++ = current_left_sample;
2134
2135 if (channels == 2){
2136 next_right_sample = sign_extend(byte, 4) * (1 << shift_right);
2137
2138 next_right_sample = (next_right_sample +
2139 (current_right_sample * coeff1r) +
2140 (previous_right_sample * coeff2r) + 0x80) >> 8;
2141
2142 previous_right_sample = current_right_sample;
2143 current_right_sample = av_clip_int16(next_right_sample);
2144 *samples++ = current_right_sample;
2145 } else {
2146 next_left_sample = sign_extend(byte, 4) * (1 << shift_left);
2147
2148 next_left_sample = (next_left_sample +
2149 (current_left_sample * coeff1l) +
2150 (previous_left_sample * coeff2l) + 0x80) >> 8;
2151
2152 previous_left_sample = current_left_sample;
2153 current_left_sample = av_clip_int16(next_left_sample);
2154
2155 *samples++ = current_left_sample;
2156 }
2157 }
2158 }
2159 bytestream2_skip(&gb, channels == 2 ? 2 : 3); // Skip terminating NULs
2160 ) /* End of CASE */
2161 CASE(ADPCM_EA_MAXIS_XA,
2162 int coeff[2][2], shift[2];
2163
2164 for (int channel = 0; channel < channels; channel++) {
2165 int byte = bytestream2_get_byteu(&gb);
2166 for (int i = 0; i < 2; i++)
2167 coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
2168 shift[channel] = 20 - (byte & 0x0F);
2169 }
2170 for (int count1 = 0; count1 < nb_samples / 2; count1++) {
2171 int byte[2];
2172
2173 byte[0] = bytestream2_get_byteu(&gb);
2174 if (st) byte[1] = bytestream2_get_byteu(&gb);
2175 for (int i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
2176 for (int channel = 0; channel < channels; channel++) {
2177 int sample = sign_extend(byte[channel] >> i, 4) * (1 << shift[channel]);
2178 sample = (sample +
2179 c->status[channel].sample1 * coeff[channel][0] +
2180 c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
2181 c->status[channel].sample2 = c->status[channel].sample1;
2182 c->status[channel].sample1 = av_clip_int16(sample);
2183 *samples++ = c->status[channel].sample1;
2184 }
2185 }
2186 }
2187 bytestream2_seek(&gb, 0, SEEK_END);
2188 ) /* End of CASE */
2189#if CONFIG_ADPCM_EA_R1_DECODER || CONFIG_ADPCM_EA_R2_DECODER || CONFIG_ADPCM_EA_R3_DECODER
2190 case AV_CODEC_ID_ADPCM_EA_R1:
2191 case AV_CODEC_ID_ADPCM_EA_R2:
2192 case AV_CODEC_ID_ADPCM_EA_R3: {
2193 /* channel numbering
2194 2chan: 0=fl, 1=fr
2195 4chan: 0=fl, 1=rl, 2=fr, 3=rr
2196 6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */
2197 const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
2198 int previous_sample, current_sample, next_sample;
2199 int coeff1, coeff2;
2200 int shift;
2201 uint16_t *samplesC;
2202 int count = 0;
2203 int offsets[6];
2204
2205 for (unsigned channel = 0; channel < channels; channel++)
2206 offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
2207 bytestream2_get_le32(&gb)) +
2208 (channels + 1) * 4;
2209
2210 for (unsigned channel = 0; channel < channels; channel++) {
2211 int count1;
2212
2213 bytestream2_seek(&gb, offsets[channel], SEEK_SET);
2214 samplesC = samples_p[channel];
2215
2216 if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
2217 current_sample = sign_extend(bytestream2_get_le16(&gb), 16);
2218 previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
2219 } else {
2220 current_sample = c->status[channel].predictor;
2221 previous_sample = c->status[channel].prev_sample;
2222 }
2223
2224 for (count1 = 0; count1 < nb_samples / 28; count1++) {
2225 int byte = bytestream2_get_byte(&gb);
2226 if (byte == 0xEE) { /* only seen in R2 and R3 */
2227 current_sample = sign_extend(bytestream2_get_be16(&gb), 16);
2228 previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);
2229
2230 for (int count2 = 0; count2 < 28; count2++)
2231 *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
2232 } else {
2233 coeff1 = ea_adpcm_table[ byte >> 4 ];
2234 coeff2 = ea_adpcm_table[(byte >> 4) + 4];
2235 shift = 20 - (byte & 0x0F);
2236
2237 for (int count2 = 0; count2 < 28; count2++) {
2238 if (count2 & 1)
2239 next_sample = (unsigned)sign_extend(byte, 4) << shift;
2240 else {
2241 byte = bytestream2_get_byte(&gb);
2242 next_sample = (unsigned)sign_extend(byte >> 4, 4) << shift;
2243 }
2244
2245 next_sample += (current_sample * coeff1) +
2246 (previous_sample * coeff2);
2247 next_sample = av_clip_int16(next_sample >> 8);
2248
2249 previous_sample = current_sample;
2250 current_sample = next_sample;
2251 *samplesC++ = current_sample;
2252 }
2253 }
2254 }
2255 if (!count) {
2256 count = count1;
2257 } else if (count != count1) {
2258 av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
2259 count = FFMAX(count, count1);
2260 }
2261
2262 if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
2263 c->status[channel].predictor = current_sample;
2264 c->status[channel].prev_sample = previous_sample;
2265 }
2266 }
2267
2268 frame->nb_samples = count * 28;
2269 bytestream2_seek(&gb, 0, SEEK_END);
2270 break;
2271 }
2272#endif /* CONFIG_ADPCM_EA_Rx_DECODER */
2273 CASE(ADPCM_EA_XAS,
2274 for (int channel=0; channel < channels; channel++) {
2275 int coeff[2][4], shift[4];
2276 int16_t *s = samples_p[channel];
2277 for (int n = 0; n < 4; n++, s += 32) {
2278 int val = sign_extend(bytestream2_get_le16u(&gb), 16);
2279 for (int i = 0; i < 2; i++)
2280 coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];
2281 s[0] = val & ~0x0F;
2282
2283 val = sign_extend(bytestream2_get_le16u(&gb), 16);
2284 shift[n] = 20 - (val & 0x0F);
2285 s[1] = val & ~0x0F;
2286 }
2287
2288 for (int m = 2; m < 32; m += 2) {
2289 s = &samples_p[channel][m];
2290 for (int n = 0; n < 4; n++, s += 32) {
2291 int level, pred;
2292 int byte = bytestream2_get_byteu(&gb);
2293
2294 level = sign_extend(byte >> 4, 4) * (1 << shift[n]);
2295 pred = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
2296 s[0] = av_clip_int16((level + pred + 0x80) >> 8);
2297
2298 level = sign_extend(byte, 4) * (1 << shift[n]);
2299 pred = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
2300 s[1] = av_clip_int16((level + pred + 0x80) >> 8);
2301 }
2302 }
2303 }
2304 ) /* End of CASE */
2305 CASE(ADPCM_IMA_ACORN,
2306 for (int channel = 0; channel < channels; channel++) {
2307 ADPCMChannelStatus *cs = &c->status[channel];
2308 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
2309 cs->step_index = bytestream2_get_le16u(&gb) & 0xFF;
2310 if (cs->step_index > 88u){
2311 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
2312 channel, cs->step_index);
2313 return AVERROR_INVALIDDATA;
2314 }
2315 }
2316 for (int n = nb_samples >> (1 - st); n > 0; n--) {
2317 int byte = bytestream2_get_byteu(&gb);
2318 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte & 0x0F, 3);
2319 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte >> 4, 3);
2320 }
2321 ) /* End of CASE */
2322 CASE(ADPCM_IMA_AMV,
2323 av_assert0(channels == 1);
2324
2325 /*
2326 * Header format:
2327 * int16_t predictor;
2328 * uint8_t step_index;
2329 * uint8_t reserved;
2330 * uint32_t frame_size;
2331 *
2332 * Some implementations have step_index as 16-bits, but others
2333 * only use the lower 8 and store garbage in the upper 8.
2334 */
2335 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
2336 c->status[0].step_index = bytestream2_get_byteu(&gb);
2337 bytestream2_skipu(&gb, 5);
2338 if (c->status[0].step_index > 88u) {
2339 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
2340 c->status[0].step_index);
2341 return AVERROR_INVALIDDATA;
2342 }
2343
2344 for (int n = nb_samples >> 1; n > 0; n--) {
2345 int v = bytestream2_get_byteu(&gb);
2346
2347 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
2348 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v & 0xf, 3);
2349 }
2350
2351 if (nb_samples & 1) {
2352 int v = bytestream2_get_byteu(&gb);
2353 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
2354
2355 if (v & 0x0F) {
2356 /* Holds true on all the http://samples.mplayerhq.hu/amv samples. */
2357 av_log(avctx, AV_LOG_WARNING, "Last nibble set on packet with odd sample count.\n");
2358 av_log(avctx, AV_LOG_WARNING, "Sample will be skipped.\n");
2359 }
2360 }
2361 ) /* End of CASE */
2362 CASE(ADPCM_IMA_PDA,
2363 for (int i = 0; i < channels; i++) {
2364 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
2365 c->status[i].step_index = bytestream2_get_byteu(&gb);
2366 bytestream2_skipu(&gb, 1);
2367 if (c->status[i].step_index > 88u) {
2368 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
2369 c->status[i].step_index);
2370 return AVERROR_INVALIDDATA;
2371 }
2372 }
2373
2374 for (int n = nb_samples >> (1 - st); n > 0; n--) {
2375 int v = bytestream2_get_byteu(&gb);
2376
2377 *samples++ = ff_adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4 );
2378 *samples++ = ff_adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf);
2379 }
2380 ) /* End of CASE */
2381 CASE(ADPCM_IMA_SMJPEG,
2382 for (int i = 0; i < channels; i++) {
2383 c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
2384 c->status[i].step_index = bytestream2_get_byteu(&gb);
2385 bytestream2_skipu(&gb, 1);
2386 if (c->status[i].step_index > 88u) {
2387 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
2388 c->status[i].step_index);
2389 return AVERROR_INVALIDDATA;
2390 }
2391 }
2392
2393 for (int n = nb_samples >> (1 - st); n > 0; n--) {
2394 int v = bytestream2_get_byteu(&gb);
2395
2396 *samples++ = ff_adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4 );
2397 *samples++ = ff_adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf);
2398 }
2399 ) /* End of CASE */
2400 CASE(ADPCM_CT,
2401 for (int n = nb_samples >> (1 - st); n > 0; n--) {
2402 int v = bytestream2_get_byteu(&gb);
2403 *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
2404 *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
2405 }
2406 ) /* End of CASE */
2407#if CONFIG_ADPCM_SBPRO_2_DECODER || CONFIG_ADPCM_SBPRO_3_DECODER || \
2408 CONFIG_ADPCM_SBPRO_4_DECODER
2409 case AV_CODEC_ID_ADPCM_SBPRO_4:
2410 case AV_CODEC_ID_ADPCM_SBPRO_3:
2411 case AV_CODEC_ID_ADPCM_SBPRO_2:
2412 if (!c->status[0].step_index) {
2413 /* the first byte is a raw sample */
2414 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
2415 if (st)
2416 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
2417 c->status[0].step_index = 1;
2418 nb_samples--;
2419 }
2420 if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
2421 for (int n = nb_samples >> (1 - st); n > 0; n--) {
2422 int byte = bytestream2_get_byteu(&gb);
2423 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
2424 byte >> 4, 4, 0);
2425 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
2426 byte & 0x0F, 4, 0);
2427 }
2428 } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
2429 for (int n = (nb_samples<<st) / 3; n > 0; n--) {
2430 int byte = bytestream2_get_byteu(&gb);
2431 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
2432 byte >> 5 , 3, 0);
2433 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
2434 (byte >> 2) & 0x07, 3, 0);
2435 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
2436 byte & 0x03, 2, 0);
2437 }
2438 } else {
2439 for (int n = nb_samples >> (2 - st); n > 0; n--) {
2440 int byte = bytestream2_get_byteu(&gb);
2441 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
2442 byte >> 6 , 2, 2);
2443 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
2444 (byte >> 4) & 0x03, 2, 2);
2445 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
2446 (byte >> 2) & 0x03, 2, 2);
2447 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
2448 byte & 0x03, 2, 2);
2449 }
2450 }
2451 break;
2452#endif /* CONFIG_ADPCM_SBPRO_x_DECODER */
2453 CASE(ADPCM_SWF,
2454 adpcm_swf_decode(avctx, buf, buf_size, samples);
2455 bytestream2_seek(&gb, 0, SEEK_END);
2456 ) /* End of CASE */
2457 CASE(ADPCM_YAMAHA,
2458 for (int n = nb_samples >> (1 - st); n > 0; n--) {
2459 int v = bytestream2_get_byteu(&gb);
2460 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
2461 *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 );
2462 }
2463 ) /* End of CASE */
2464 CASE(ADPCM_AICA,
2465 for (int channel = 0; channel < channels; channel++) {
2466 samples = samples_p[channel];
2467 for (int n = nb_samples >> 1; n > 0; n--) {
2468 int v = bytestream2_get_byteu(&gb);
2469 *samples++ = adpcm_yamaha_expand_nibble(&c->status[channel], v & 0x0F);
2470 *samples++ = adpcm_yamaha_expand_nibble(&c->status[channel], v >> 4 );
2471 }
2472 }
2473 ) /* End of CASE */
2474 CASE(ADPCM_AFC,
2475 int samples_per_block;
2476 int blocks;
2477
2478 if (avctx->extradata && avctx->extradata_size == 1 && avctx->extradata[0]) {
2479 samples_per_block = avctx->extradata[0] / 16;
2480 blocks = nb_samples / avctx->extradata[0];
2481 } else {
2482 samples_per_block = nb_samples / 16;
2483 blocks = 1;
2484 }
2485
2486 for (int m = 0; m < blocks; m++) {
2487 for (int channel = 0; channel < channels; channel++) {
2488 int prev1 = c->status[channel].sample1;
2489 int prev2 = c->status[channel].sample2;
2490
2491 samples = samples_p[channel] + m * 16;
2492 /* Read in every sample for this channel. */
2493 for (int i = 0; i < samples_per_block; i++) {
2494 int byte = bytestream2_get_byteu(&gb);
2495 int scale = 1 << (byte >> 4);
2496 int index = byte & 0xf;
2497 int factor1 = afc_coeffs[0][index];
2498 int factor2 = afc_coeffs[1][index];
2499
2500 /* Decode 16 samples. */
2501 for (int n = 0; n < 16; n++) {
2502 int32_t sampledat;
2503
2504 if (n & 1) {
2505 sampledat = sign_extend(byte, 4);
2506 } else {
2507 byte = bytestream2_get_byteu(&gb);
2508 sampledat = sign_extend(byte >> 4, 4);
2509 }
2510
2511 sampledat = ((prev1 * factor1 + prev2 * factor2) >> 11) +
2512 sampledat * scale;
2513 *samples = av_clip_int16(sampledat);
2514 prev2 = prev1;
2515 prev1 = *samples++;
2516 }
2517 }
2518
2519 c->status[channel].sample1 = prev1;
2520 c->status[channel].sample2 = prev2;
2521 }
2522 }
2523 bytestream2_seek(&gb, 0, SEEK_END);
2524 ) /* End of CASE */
2525#if CONFIG_ADPCM_THP_DECODER || CONFIG_ADPCM_THP_LE_DECODER
2526 case AV_CODEC_ID_ADPCM_THP:
2527 case AV_CODEC_ID_ADPCM_THP_LE:
2528 {
2529 int table[14][16];
2530
2531#define THP_GET16(g) \
2532 sign_extend( \
2533 avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE ? \
2534 bytestream2_get_le16u(&(g)) : \
2535 bytestream2_get_be16u(&(g)), 16)
2536
2537 if (avctx->extradata) {
2538 GetByteContext tb;
2539 if (avctx->extradata_size < 32 * channels) {
2540 av_log(avctx, AV_LOG_ERROR, "Missing coeff table\n");
2541 return AVERROR_INVALIDDATA;
2542 }
2543
2544 bytestream2_init(&tb, avctx->extradata, avctx->extradata_size);
2545 for (int i = 0; i < channels; i++)
2546 for (int n = 0; n < 16; n++)
2547 table[i][n] = THP_GET16(tb);
2548 } else {
2549 for (int i = 0; i < channels; i++)
2550 for (int n = 0; n < 16; n++)
2551 table[i][n] = THP_GET16(gb);
2552
2553 if (!c->has_status) {
2554 /* Initialize the previous sample. */
2555 for (int i = 0; i < channels; i++) {
2556 c->status[i].sample1 = THP_GET16(gb);
2557 c->status[i].sample2 = THP_GET16(gb);
2558 }
2559 c->has_status = 1;
2560 } else {
2561 bytestream2_skip(&gb, channels * 4);
2562 }
2563 }
2564
2565 for (int ch = 0; ch < channels; ch++) {
2566 samples = samples_p[ch];
2567
2568 /* Read in every sample for this channel. */
2569 for (int i = 0; i < (nb_samples + 13) / 14; i++) {
2570 int byte = bytestream2_get_byteu(&gb);
2571 int index = (byte >> 4) & 7;
2572 unsigned int exp = byte & 0x0F;
2573 int64_t factor1 = table[ch][index * 2];
2574 int64_t factor2 = table[ch][index * 2 + 1];
2575
2576 /* Decode 14 samples. */
2577 for (int n = 0; n < 14 && (i * 14 + n < nb_samples); n++) {
2578 int32_t sampledat;
2579
2580 if (n & 1) {
2581 sampledat = sign_extend(byte, 4);
2582 } else {
2583 byte = bytestream2_get_byteu(&gb);
2584 sampledat = sign_extend(byte >> 4, 4);
2585 }
2586
2587 sampledat = ((c->status[ch].sample1 * factor1
2588 + c->status[ch].sample2 * factor2) >> 11) + sampledat * (1 << exp);
2589 *samples = av_clip_int16(sampledat);
2590 c->status[ch].sample2 = c->status[ch].sample1;
2591 c->status[ch].sample1 = *samples++;
2592 }
2593 }
2594 }
2595 break;
2596 }
2597#endif /* CONFIG_ADPCM_THP(_LE)_DECODER */
2598 CASE(ADPCM_DTK,
2599 for (int channel = 0; channel < channels; channel++) {
2600 samples = samples_p[channel];
2601
2602 /* Read in every sample for this channel. */
2603 for (int i = 0; i < nb_samples / 28; i++) {
2604 int byte, header;
2605 if (channel)
2606 bytestream2_skipu(&gb, 1);
2607 header = bytestream2_get_byteu(&gb);
2608 bytestream2_skipu(&gb, 3 - channel);
2609
2610 /* Decode 28 samples. */
2611 for (int n = 0; n < 28; n++) {
2612 int32_t sampledat, prev;
2613
2614 switch (header >> 4) {
2615 case 1:
2616 prev = (c->status[channel].sample1 * 0x3c);
2617 break;
2618 case 2:
2619 prev = (c->status[channel].sample1 * 0x73) - (c->status[channel].sample2 * 0x34);
2620 break;
2621 case 3:
2622 prev = (c->status[channel].sample1 * 0x62) - (c->status[channel].sample2 * 0x37);
2623 break;
2624 default:
2625 prev = 0;
2626 }
2627
2628 prev = av_clip_intp2((prev + 0x20) >> 6, 21);
2629
2630 byte = bytestream2_get_byteu(&gb);
2631 if (!channel)
2632 sampledat = sign_extend(byte, 4);
2633 else
2634 sampledat = sign_extend(byte >> 4, 4);
2635
2636 sampledat = ((sampledat * (1 << 12)) >> (header & 0xf)) * (1 << 6) + prev;
2637 *samples++ = av_clip_int16(sampledat >> 6);
2638 c->status[channel].sample2 = c->status[channel].sample1;
2639 c->status[channel].sample1 = sampledat;
2640 }
2641 }
2642 if (!channel)
2643 bytestream2_seek(&gb, 0, SEEK_SET);
2644 }
2645 ) /* End of CASE */
2646 CASE(ADPCM_N64,
2647 ADPCMChannelStatus *cs = &c->status[0];
2648 int coefs[8*2*8] = { 0 };
2649
2650 if (avctx->extradata) {
2651 int version, order, entries;
2652 GetByteContext cb;
2653
2654 bytestream2_init(&cb, avctx->extradata, avctx->extradata_size);
2655
2656 version = bytestream2_get_be16(&cb);
2657 order = bytestream2_get_be16(&cb);
2658 entries = bytestream2_get_be16(&cb);
2659 if (version != 1 || order != 2 || entries > 8)
2660 return AVERROR_INVALIDDATA;
2661
2662 for (int n = 0; n < order * entries * 8; n++)
2663 coefs[n] = sign_extend(bytestream2_get_be16(&cb), 16);
2664 }
2665
2666 for (int block = 0; block < avpkt->size / 9; block++) {
2667 int scale, index, codes[16];
2668 int16_t hist[8] = { 0 };
2669 const int order = 2;
2670 int16_t out[16];
2671
2672 hist[6] = cs->sample2;
2673 hist[7] = cs->sample1;
2674
2675 samples = samples_p[0] + block * 16;
2676
2677 scale = (buf[0] >> 4) & 0xF;
2678 index = (buf[0] >> 0) & 0xF;
2679 scale = 1 << scale;
2680 index = FFMIN(index, 8);
2681
2682 for (int i = 0, j = 0; i < 16; i += 2, j++) {
2683 int n0 = (buf[j+1] >> 4) & 0xF;
2684 int n1 = (buf[j+1] >> 0) & 0xF;
2685
2686 if (n0 & 8)
2687 n0 = n0 - 16;
2688 if (n1 & 8)
2689 n1 = n1 - 16;
2690
2691 codes[i+0] = n0 * scale;
2692 codes[i+1] = n1 * scale;
2693 }
2694
2695 for (int j = 0; j < 2; j++) {
2696 int *sf_codes = &codes[j*8];
2697 int16_t *sf_out = &out[j*8];
2698
2699 for (int i = 0; i < 8; i++) {
2700 int sample;
2701 unsigned delta = 0;
2702
2703 for (int o = 0; o < order; o++)
2704 delta += coefs[o*8 + i] * hist[(8 - order) + o];
2705
2706 for (int k = i-1; k > -1; k--) {
2707 for (int o = 1; o < order; o++)
2708 delta += sf_codes[(i-1) - k] * (unsigned)coefs[(o*8) + k];
2709 }
2710
2711 sample = sf_codes[i] * 2048;
2712 sample = (int)(sample + delta) / 2048;
2713 sample = av_clip_int16(sample);
2714 sf_out[i] = sample;
2715 }
2716
2717 for (int i = 8 - order; i < 8; i++)
2718 hist[i] = sf_out[i];
2719 }
2720
2721 memcpy(samples, out, sizeof(out));
2722
2723 cs->sample2 = hist[6];
2724 cs->sample1 = hist[7];
2725
2726 buf += 9;
2727 }
2728 bytestream2_seek(&gb, 0, SEEK_END);
2729 ) /* End of CASE */
2730 CASE(ADPCM_PSX,
2731 for (int block = 0; block < avpkt->size / FFMAX(avctx->block_align, 16 * channels); block++) {
2732 int nb_samples_per_block = 28 * FFMAX(avctx->block_align, 16 * channels) / (16 * channels);
2733 for (int channel = 0; channel < channels; channel++) {
2734 samples = samples_p[channel] + block * nb_samples_per_block;
2735 av_assert0((block + 1) * nb_samples_per_block <= nb_samples);
2736
2737 /* Read in every sample for this channel. */
2738 for (int i = 0; i < nb_samples_per_block / 28; i++) {
2739 int filter, shift, flag, byte;
2740
2741 filter = bytestream2_get_byteu(&gb);
2742 shift = filter & 0xf;
2743 filter = filter >> 4;
2744 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table))
2745 return AVERROR_INVALIDDATA;
2746 flag = bytestream2_get_byteu(&gb) & 0x7;
2747
2748 /* Decode 28 samples. */
2749 for (int n = 0; n < 28; n++) {
2750 int sample = 0, scale;
2751
2752 if (n & 1) {
2753 scale = sign_extend(byte >> 4, 4);
2754 } else {
2755 byte = bytestream2_get_byteu(&gb);
2756 scale = sign_extend(byte, 4);
2757 }
2758
2759 if (flag < 0x07) {
2760 scale = scale * (1 << 12);
2761 sample = (int)((scale >> shift) + (c->status[channel].sample1 * xa_adpcm_table[filter][0] + c->status[channel].sample2 * xa_adpcm_table[filter][1]) / 64);
2762 }
2763 *samples++ = av_clip_int16(sample);
2764 c->status[channel].sample2 = c->status[channel].sample1;
2765 c->status[channel].sample1 = sample;
2766 }
2767 }
2768 }
2769 }
2770 ) /* End of CASE */
2771 CASE(ADPCM_PSXC,
2772 for (int block = 0; block < avpkt->size / avctx->block_align; block++) {
2773 int nb_samples_per_block = ((avctx->block_align - 1) / channels) * 2;
2774 for (int channel = 0; channel < channels; channel++) {
2775 int filter, shift, byte;
2776
2777 samples = samples_p[channel] + block * nb_samples_per_block;
2778 av_assert0((block + 1) * nb_samples_per_block <= nb_samples);
2779
2780 filter = bytestream2_get_byteu(&gb);
2781 shift = filter & 0xf;
2782 filter = filter >> 4;
2783 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table))
2784 return AVERROR_INVALIDDATA;
2785
2786 for (int n = 0; n < nb_samples_per_block; n++) {
2787 int sample = 0, scale;
2788
2789 if (n & 1) {
2790 scale = sign_extend(byte >> 4, 4);
2791 } else {
2792 byte = bytestream2_get_byteu(&gb);
2793 scale = sign_extend(byte & 0xF, 4);
2794 }
2795
2796 scale = scale * (1 << 12);
2797 sample = (int)((scale >> shift) + (c->status[channel].sample1 * xa_adpcm_table[filter][0] + c->status[channel].sample2 * xa_adpcm_table[filter][1]) / 64);
2798 *samples++ = av_clip_int16(sample);
2799 c->status[channel].sample2 = c->status[channel].sample1;
2800 c->status[channel].sample1 = sample;
2801 }
2802 }
2803 }
2804 ) /* End of CASE */
2805 CASE(ADPCM_SANYO,
2806 int (*expand)(ADPCMChannelStatus *c, int bits);
2807 GetBitContext g;
2808
2809 switch(avctx->bits_per_coded_sample) {
2810 case 3: expand = adpcm_sanyo_expand3; break;
2811 case 4: expand = adpcm_sanyo_expand4; break;
2812 case 5: expand = adpcm_sanyo_expand5; break;
2813 }
2814
2815 for (int ch = 0; ch < channels; ch++) {
2816 c->status[ch].predictor = sign_extend(bytestream2_get_le16(&gb), 16);
2817 c->status[ch].step = sign_extend(bytestream2_get_le16(&gb), 16);
2818 }
2819
2820 init_get_bits8(&g, gb.buffer, bytestream2_get_bytes_left(&gb));
2821 for (int i = 0; i < nb_samples; i++)
2822 for (int ch = 0; ch < channels; ch++)
2823 samples_p[ch][i] = expand(&c->status[ch], get_bits_le(&g, avctx->bits_per_coded_sample));
2824
2825 align_get_bits(&g);
2826 bytestream2_skip(&gb, get_bits_count(&g) / 8);
2827 ) /* End of CASE */
2828 CASE(ADPCM_ARGO,
2829 /*
2830 * The format of each block:
2831 * uint8_t left_control;
2832 * uint4_t left_samples[nb_samples];
2833 * ---- and if stereo ----
2834 * uint8_t right_control;
2835 * uint4_t right_samples[nb_samples];
2836 *
2837 * Format of the control byte:
2838 * MSB [SSSSRDRR] LSB
2839 * S = (Shift Amount - 2)
2840 * D = Decoder flag.
2841 * R = Reserved
2842 *
2843 * Each block relies on the previous two samples of each channel.
2844 * They should be 0 initially.
2845 */
2846 for (int block = 0; block < avpkt->size / avctx->block_align; block++) {
2847 for (int channel = 0; channel < avctx->ch_layout.nb_channels; channel++) {
2848 ADPCMChannelStatus *cs = c->status + channel;
2849 int control, shift;
2850
2851 samples = samples_p[channel] + block * 32;
2852
2853 /* Get the control byte and decode the samples, 2 at a time. */
2854 control = bytestream2_get_byteu(&gb);
2855 shift = (control >> 4) + 2;
2856
2857 for (int n = 0; n < 16; n++) {
2858 int sample = bytestream2_get_byteu(&gb);
2859 *samples++ = ff_adpcm_argo_expand_nibble(cs, sample >> 4, shift, control & 0x04);
2860 *samples++ = ff_adpcm_argo_expand_nibble(cs, sample >> 0, shift, control & 0x04);
2861 }
2862 }
2863 }
2864 ) /* End of CASE */
2865 CASE(ADPCM_CIRCUS,
2866 for (int n = 0; n < nb_samples; n++) {
2867 for (int ch = 0; ch < channels; ch++) {
2868 int v = bytestream2_get_byteu(&gb);
2869 *samples++ = adpcm_circus_expand_nibble(&c->status[ch], v);
2870 }
2871 }
2872 ) /* End of CASE */
2873 CASE(ADPCM_ZORK,
2874 for (int n = 0; n < nb_samples * channels; n++) {
2875 int v = bytestream2_get_byteu(&gb);
2876 *samples++ = adpcm_zork_expand_nibble(&c->status[n % channels], v);
2877 }
2878 ) /* End of CASE */
2879 CASE(ADPCM_IMA_MTF,
2880 for (int n = nb_samples / 2; n > 0; n--) {
2881 for (int channel = 0; channel < channels; channel++) {
2882 int v = bytestream2_get_byteu(&gb);
2883 *samples++ = adpcm_ima_mtf_expand_nibble(&c->status[channel], v >> 4);
2884 samples[st] = adpcm_ima_mtf_expand_nibble(&c->status[channel], v & 0x0F);
2885 }
2886 samples += channels;
2887 }
2888 ) /* End of CASE */
2889 default:
2890 av_unreachable("There are cases for all codec ids using adpcm_decode_frame");
2891 }
2892
2893 if (avpkt->size && bytestream2_tell(&gb) == 0) {
2894 av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n");
2895 return AVERROR_INVALIDDATA;
2896 }
2897
2898 *got_frame_ptr = 1;
2899
2900 if (avpkt->size < bytestream2_tell(&gb)) {
2901 av_log(avctx, AV_LOG_ERROR, "Overread of %d < %d\n", avpkt->size, bytestream2_tell(&gb));
2902 return avpkt->size;
2903 }
2904
2905 return bytestream2_tell(&gb);
2906}
2907
2908static av_cold void adpcm_flush(AVCodecContext *avctx)
2909{
2910 ADPCMDecodeContext *c = avctx->priv_data;
2911
2912 /* Just nuke the entire state and re-init. */
2913 memset(c, 0, sizeof(ADPCMDecodeContext));
2914
2915 switch(avctx->codec_id) {
2916 case AV_CODEC_ID_ADPCM_CT:
2917 c->status[0].step = c->status[1].step = 511;
2918 break;
2919
2920 case AV_CODEC_ID_ADPCM_IMA_APC:
2921 if (avctx->extradata && avctx->extradata_size >= 8) {
2922 c->status[0].predictor = av_clip_intp2(AV_RL32(avctx->extradata ), 18);
2923 c->status[1].predictor = av_clip_intp2(AV_RL32(avctx->extradata + 4), 18);
2924 }
2925 break;
2926
2927 case AV_CODEC_ID_ADPCM_IMA_APM:
2928 if (avctx->extradata && avctx->extradata_size >= 28) {
2929 c->status[0].predictor = av_clip_intp2(AV_RL32(avctx->extradata + 16), 18);
2930 c->status[0].step_index = av_clip(AV_RL32(avctx->extradata + 20), 0, 88);
2931 c->status[1].predictor = av_clip_intp2(AV_RL32(avctx->extradata + 4), 18);
2932 c->status[1].step_index = av_clip(AV_RL32(avctx->extradata + 8), 0, 88);
2933 }
2934 break;
2935
2936 case AV_CODEC_ID_ADPCM_IMA_WS:
2937 if (avctx->extradata && avctx->extradata_size >= 2)
2938 c->vqa_version = AV_RL16(avctx->extradata);
2939 break;
2940 default:
2941 /* Other codecs may want to handle this during decoding. */
2942 c->has_status = 0;
2943 return;
2944 }
2945
2946 c->has_status = 1;
2947}
2948
2949
2950#define ADPCM_DECODER_0(id_, name_, long_name_)
2951#define ADPCM_DECODER_1(id_, name_, long_name_) \
2952const FFCodec ff_ ## name_ ## _decoder = { \
2953 .p.name = #name_, \
2954 CODEC_LONG_NAME(long_name_), \
2955 .p.type = AVMEDIA_TYPE_AUDIO, \
2956 .p.id = id_, \
2957 .p.capabilities = AV_CODEC_CAP_DR1, \
2958 .priv_data_size = sizeof(ADPCMDecodeContext), \
2959 .init = adpcm_decode_init, \
2960 FF_CODEC_DECODE_CB(adpcm_decode_frame), \
2961 .flush = adpcm_flush, \
2962};
2963#define ADPCM_DECODER_2(enabled, codec_id, name, long_name) \
2964 ADPCM_DECODER_ ## enabled(codec_id, name, long_name)
2965#define ADPCM_DECODER_3(config, codec_id, name, long_name) \
2966 ADPCM_DECODER_2(config, codec_id, name, long_name)
2967#define ADPCM_DECODER(codec, name, long_name) \
2968 ADPCM_DECODER_3(CONFIG_ ## codec ## _DECODER, AV_CODEC_ID_ ## codec, \
2969 name, long_name)
2970
2971/* Note: Do not forget to add new entries to the Makefile as well. */
2972ADPCM_DECODER(ADPCM_4XM, adpcm_4xm, "ADPCM 4X Movie")
2973ADPCM_DECODER(ADPCM_AFC, adpcm_afc, "ADPCM Nintendo Gamecube AFC")
2974ADPCM_DECODER(ADPCM_AGM, adpcm_agm, "ADPCM AmuseGraphics Movie")
2975ADPCM_DECODER(ADPCM_AICA, adpcm_aica, "ADPCM Yamaha AICA")
2976ADPCM_DECODER(ADPCM_ARGO, adpcm_argo, "ADPCM Argonaut Games")
2977ADPCM_DECODER(ADPCM_CIRCUS, adpcm_circus, "ADPCM Circus")
2978ADPCM_DECODER(ADPCM_CT, adpcm_ct, "ADPCM Creative Technology")
2979ADPCM_DECODER(ADPCM_DTK, adpcm_dtk, "ADPCM Nintendo Gamecube DTK")
2980ADPCM_DECODER(ADPCM_EA, adpcm_ea, "ADPCM Electronic Arts")
2981ADPCM_DECODER(ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA")
2982ADPCM_DECODER(ADPCM_EA_R1, adpcm_ea_r1, "ADPCM Electronic Arts R1")
2983ADPCM_DECODER(ADPCM_EA_R2, adpcm_ea_r2, "ADPCM Electronic Arts R2")
2984ADPCM_DECODER(ADPCM_EA_R3, adpcm_ea_r3, "ADPCM Electronic Arts R3")
2985ADPCM_DECODER(ADPCM_EA_XAS, adpcm_ea_xas, "ADPCM Electronic Arts XAS")
2986ADPCM_DECODER(ADPCM_IMA_ACORN, adpcm_ima_acorn, "ADPCM IMA Acorn Replay")
2987ADPCM_DECODER(ADPCM_IMA_AMV, adpcm_ima_amv, "ADPCM IMA AMV")
2988ADPCM_DECODER(ADPCM_IMA_APC, adpcm_ima_apc, "ADPCM IMA CRYO APC")
2989ADPCM_DECODER(ADPCM_IMA_APM, adpcm_ima_apm, "ADPCM IMA Ubisoft APM")
2990ADPCM_DECODER(ADPCM_IMA_CUNNING, adpcm_ima_cunning, "ADPCM IMA Cunning Developments")
2991ADPCM_DECODER(ADPCM_IMA_DAT4, adpcm_ima_dat4, "ADPCM IMA Eurocom DAT4")
2992ADPCM_DECODER(ADPCM_IMA_DK3, adpcm_ima_dk3, "ADPCM IMA Duck DK3")
2993ADPCM_DECODER(ADPCM_IMA_DK4, adpcm_ima_dk4, "ADPCM IMA Duck DK4")
2994ADPCM_DECODER(ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS")
2995ADPCM_DECODER(ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD")
2996ADPCM_DECODER(ADPCM_IMA_ESCAPE, adpcm_ima_escape, "ADPCM IMA Acorn Escape")
2997ADPCM_DECODER(ADPCM_IMA_HVQM2, adpcm_ima_hvqm2, "ADPCM IMA HVQM2")
2998ADPCM_DECODER(ADPCM_IMA_HVQM4, adpcm_ima_hvqm4, "ADPCM IMA HVQM4")
2999ADPCM_DECODER(ADPCM_IMA_ISS, adpcm_ima_iss, "ADPCM IMA Funcom ISS")
3000ADPCM_DECODER(ADPCM_IMA_MAGIX, adpcm_ima_magix, "ADPCM IMA Magix")
3001ADPCM_DECODER(ADPCM_IMA_MOFLEX, adpcm_ima_moflex, "ADPCM IMA MobiClip MOFLEX")
3002ADPCM_DECODER(ADPCM_IMA_MTF, adpcm_ima_mtf, "ADPCM IMA Capcom's MT Framework")
3003ADPCM_DECODER(ADPCM_IMA_OKI, adpcm_ima_oki, "ADPCM IMA Dialogic OKI")
3004ADPCM_DECODER(ADPCM_IMA_PDA, adpcm_ima_pda, "ADPCM IMA PlayDate")
3005ADPCM_DECODER(ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime")
3006ADPCM_DECODER(ADPCM_IMA_RAD, adpcm_ima_rad, "ADPCM IMA Radical")
3007ADPCM_DECODER(ADPCM_IMA_SSI, adpcm_ima_ssi, "ADPCM IMA Simon & Schuster Interactive")
3008ADPCM_DECODER(ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG")
3009ADPCM_DECODER(ADPCM_IMA_ALP, adpcm_ima_alp, "ADPCM IMA High Voltage Software ALP")
3010ADPCM_DECODER(ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV")
3011ADPCM_DECODER(ADPCM_IMA_WS, adpcm_ima_ws, "ADPCM IMA Westwood")
3012ADPCM_DECODER(ADPCM_IMA_XBOX, adpcm_ima_xbox, "ADPCM IMA Xbox")
3013ADPCM_DECODER(ADPCM_MS, adpcm_ms, "ADPCM Microsoft")
3014ADPCM_DECODER(ADPCM_MTAF, adpcm_mtaf, "ADPCM MTAF")
3015ADPCM_DECODER(ADPCM_N64, adpcm_n64, "ADPCM Silicon Graphics N64")
3016ADPCM_DECODER(ADPCM_PSX, adpcm_psx, "ADPCM Playstation")
3017ADPCM_DECODER(ADPCM_PSXC, adpcm_psxc, "ADPCM Playstation C")
3018ADPCM_DECODER(ADPCM_SANYO, adpcm_sanyo, "ADPCM Sanyo")
3019ADPCM_DECODER(ADPCM_SBPRO_2, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit")
3020ADPCM_DECODER(ADPCM_SBPRO_3, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit")
3021ADPCM_DECODER(ADPCM_SBPRO_4, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit")
3022ADPCM_DECODER(ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash")
3023ADPCM_DECODER(ADPCM_THP_LE, adpcm_thp_le, "ADPCM Nintendo THP (little-endian)")
3024ADPCM_DECODER(ADPCM_THP, adpcm_thp, "ADPCM Nintendo THP")
3025ADPCM_DECODER(ADPCM_XA, adpcm_xa, "ADPCM CDROM XA")
3026ADPCM_DECODER(ADPCM_XMD, adpcm_xmd, "ADPCM Konami XMD")
3027ADPCM_DECODER(ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha")
3028ADPCM_DECODER(ADPCM_ZORK, adpcm_zork, "ADPCM Zork")
ff_adpcm_argo_expand_nibble
int16_t ff_adpcm_argo_expand_nibble(ADPCMChannelStatus *cs, int nibble, int shift, int flag)
Definition adpcm.c:969
ima_cunning_index_table
static const int8_t ima_cunning_index_table[9]
Definition adpcm.c:111
swf_index_tables
static const int8_t swf_index_tables[4][16]
Definition adpcm.c:228
ff_adpcm_ima_qt_expand_nibble
int16_t ff_adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble)
Definition adpcm.c:557
decode_adpcm_ima_hvqm4
static void decode_adpcm_ima_hvqm4(AVCodecContext *avctx, int16_t *outbuf, int samples_to_do, int frame_format, GetByteContext *gb)
Definition adpcm.c:620
adpcm_ima_expand_nibble
static int16_t adpcm_ima_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
Definition adpcm.c:447
adpcm_flush
static void adpcm_flush(AVCodecContext *avctx)
Definition adpcm.c:2908
adpcm_sanyo_expand5
static int adpcm_sanyo_expand5(ADPCMChannelStatus *c, int bits)
Definition adpcm.c:1088
adpcm_mtaf_expand_nibble
static int16_t adpcm_mtaf_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
Definition adpcm.c:758
adpcm_ima_oki_expand_nibble
static int16_t adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)
Definition adpcm.c:682
adpcm_ima_mtf_expand_nibble
static int16_t adpcm_ima_mtf_expand_nibble(ADPCMChannelStatus *c, int nibble)
Definition adpcm.c:496
adpcm_index_tables
static const int8_t *const adpcm_index_tables[4]
Definition adpcm.c:145
afc_coeffs
static const int16_t afc_coeffs[2][16]
Definition adpcm.c:92
DK3_GET_NEXT_NIBBLE
#define DK3_GET_NEXT_NIBBLE()
adpcm_ima_wav_expand_nibble
static int16_t adpcm_ima_wav_expand_nibble(ADPCMChannelStatus *c, GetBitContext *gb, int bps)
Definition adpcm.c:532
adpcm_index_table3
static const int8_t adpcm_index_table3[8]
Definition adpcm.c:135
adpcm_sanyo_expand3
static int adpcm_sanyo_expand3(ADPCMChannelStatus *c, int bits)
Definition adpcm.c:986
mtaf_stepsize
static const int16_t mtaf_stepsize[32][16]
Definition adpcm.c:152
oki_step_table
static const int16_t oki_step_table[49]
Definition adpcm.c:219
adpcm_sbpro_expand_nibble
static int16_t adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int size, int shift)
Definition adpcm.c:724
adpcm_swf_decode
static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
Definition adpcm.c:911
CASE
#define CASE(codec,...)
Definition adpcm.c:80
xa_adpcm_table
static const int8_t xa_adpcm_table[5][2]
Definition adpcm.c:84
get_nb_samples
static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, int buf_size, int *coded_samples, int *approx_nb_samples)
Get the number of samples (per channel) that will be decoded from the packet.
Definition adpcm.c:1163
adpcm_index_table2
static const int8_t adpcm_index_table2[4]
Definition adpcm.c:130
adpcm_agm_expand_nibble
static int16_t adpcm_agm_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
Definition adpcm.c:380
adpcm_ima_alp_expand_nibble
static int16_t adpcm_ima_alp_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
Definition adpcm.c:473
xa_decode
static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1, const uint8_t *in, ADPCMChannelStatus *left, ADPCMChannelStatus *right, int channels, int sample_offset)
Definition adpcm.c:823
ea_adpcm_table
static const int16_t ea_adpcm_table[]
Definition adpcm.c:97
adpcm_circus_expand_nibble
static int16_t adpcm_circus_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
Definition adpcm.c:767
adpcm_index_table5
static const int8_t adpcm_index_table5[32]
Definition adpcm.c:140
adpcm_ima_escape_expand_nibble
static int16_t adpcm_ima_escape_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
Definition adpcm.c:424
adpcm_zork_expand_nibble
static int16_t adpcm_zork_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
Definition adpcm.c:788
adpcm_yamaha_expand_nibble
static int16_t adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
Definition adpcm.c:744
zork_index_table
static const int8_t zork_index_table[8]
Definition adpcm.c:235
adpcm_sanyo_expand4
static int adpcm_sanyo_expand4(ADPCMChannelStatus *c, int bits)
Definition adpcm.c:1029
adpcm_ima_cunning_expand_nibble
static int16_t adpcm_ima_cunning_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
Definition adpcm.c:512
decode_adpcm_ima_hvqm2
static void decode_adpcm_ima_hvqm2(AVCodecContext *avctx, int16_t *outbuf, int samples_to_do, int frame_format, GetByteContext *gb)
Definition adpcm.c:583
ima_cunning_step_table
static const int16_t ima_cunning_step_table[61]
Definition adpcm.c:121
adpcm_ms_expand_nibble
static int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
Definition adpcm.c:663
mtf_index_table
static const int8_t mtf_index_table[16]
Definition adpcm.c:239
adpcm_decode_frame
static int adpcm_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition adpcm.c:1442
adpcm_ct_expand_nibble
static int16_t adpcm_ct_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
Definition adpcm.c:703
ADPCM_DECODER
#define ADPCM_DECODER(codec, name, long_name)
Definition adpcm.c:2967
adpcm_decode_init
static av_cold int adpcm_decode_init(AVCodecContext *avctx)
Definition adpcm.c:254
adpcm.h
ADPCM encoder/decoder common header.
ff_adpcm_AdaptCoeff2
const int8_t ff_adpcm_AdaptCoeff2[]
Divided by 4 to fit in 8-bit integers.
Definition adpcm_data.c:65
ff_adpcm_index_table
const int8_t ff_adpcm_index_table[16]
Definition adpcm_data.c:30
ff_adpcm_yamaha_difflookup
const int8_t ff_adpcm_yamaha_difflookup[]
Definition adpcm_data.c:74
ff_adpcm_step_table
const int16_t ff_adpcm_step_table[89]
This is the step table.
Definition adpcm_data.c:39
ff_adpcm_AdaptCoeff1
const uint8_t ff_adpcm_AdaptCoeff1[]
Divided by 4 to fit in 8-bit integers.
Definition adpcm_data.c:60
ff_adpcm_yamaha_indexscale
const int16_t ff_adpcm_yamaha_indexscale[]
Definition adpcm_data.c:69
ff_adpcm_AdaptationTable
const int16_t ff_adpcm_AdaptationTable[]
Definition adpcm_data.c:54
adpcm_data.h
ADPCM tables.
ff_adpcm_ima_block_sizes
static const uint8_t ff_adpcm_ima_block_sizes[4]
Definition adpcm_data.h:31
ff_adpcm_ima_block_samples
static const uint8_t ff_adpcm_ima_block_samples[4]
Definition adpcm_data.h:32
val
static double val(void *priv, double ch)
Definition aeval.c:77
expand
static int expand(AVFilterContext *ctx, double *pz, int n, double *coefs)
Definition af_aiir.c:499
format
static const char *const format[]
Definition af_aiir.c:444
update
static av_always_inline void update(AVFilterContext *ctx, AVFrame *insamples, int is_silence, int current_sample, int64_t nb_samples_notify, AVRational time_base)
Definition af_silencedetect.c:78
out
static FILE * out
Definition api-movenc-test.c:55
channels
channels
Definition aptx.h:31
int32_t
int32_t
Definition audioconvert.c:56
av_unreachable
#define av_unreachable(msg)
Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.
Definition avassert.h:109
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
avcodec.h
Libavcodec external API header.
bits_left
#define bits_left
Definition bitstream.h:116
skip
static void BS_FUNC skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition bitstream_template.h:383
left
static int BS_FUNC left(const BSCTX *bc)
Return the number of the bits left in a buffer.
Definition bitstream_template.h:170
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition bytestream.h:174
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(const GetByteContext *g)
Definition bytestream.h:158
byte
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition bytestream.h:99
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition bytestream.h:137
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition bytestream.h:168
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition bytestream.h:212
bytestream2_tell
static av_always_inline int bytestream2_tell(const GetByteContext *g)
Definition bytestream.h:192
flag
#define flag(name)
Definition cbs_h264.c:60
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
s
#define s(width, name)
Definition cbs_vp9.c:198
codec_internal.h
av_clip_intp2
#define av_clip_intp2
Definition common.h:121
av_clip
#define av_clip
Definition common.h:100
av_clip_int16
#define av_clip_int16
Definition common.h:115
av_zero_extend
#define av_zero_extend
Definition common.h:151
av_clip_uintp2
#define av_clip_uintp2
Definition common.h:124
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition common.h:74
NULL
#define NULL
Definition coverity.c:32
int64_t
long long int64_t
Definition coverity.c:34
abs
#define abs(x)
Definition cuda_runtime.h:35
block
static int16_t block[64]
Definition dct.c:125
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition decode.c:1777
frame
static AVFrame * frame
Definition demux_decode.c:54
channel
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition ebur128.h:39
exp
int8_t exp
Definition eval.c:76
predictor
static void predictor(uint8_t *src, ptrdiff_t size)
Definition exrenc.c:170
bits
static const uint8_t bits[8]
Definition fastaudio.c:100
sample
#define sample
Definition flacdsp_template.c:44
get_bits.h
bitstream reader API header.
get_bits_le
static unsigned int get_bits_le(GetBitContext *s, int n)
Definition get_bits.h:358
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition get_bits.h:322
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition get_bits.h:544
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition get_bits.h:560
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition get_bits.h:254
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition get_bits.h:337
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition get_bits.h:517
AV_CODEC_ID_ADPCM_IMA_PDA
@ AV_CODEC_ID_ADPCM_IMA_PDA
Definition codec_id.h:425
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition codec_id.h:383
AV_CODEC_ID_ADPCM_IMA_HVQM4
@ AV_CODEC_ID_ADPCM_IMA_HVQM4
Definition codec_id.h:424
AV_CODEC_ID_ADPCM_CT
@ AV_CODEC_ID_ADPCM_CT
Definition codec_id.h:382
AV_CODEC_ID_ADPCM_IMA_WS
@ AV_CODEC_ID_ADPCM_IMA_WS
Definition codec_id.h:374
AV_CODEC_ID_ADPCM_EA_R1
@ AV_CODEC_ID_ADPCM_EA_R1
Definition codec_id.h:390
AV_CODEC_ID_ADPCM_4XM
@ AV_CODEC_ID_ADPCM_4XM
Definition codec_id.h:377
AV_CODEC_ID_ADPCM_IMA_OKI
@ AV_CODEC_ID_ADPCM_IMA_OKI
Definition codec_id.h:402
AV_CODEC_ID_ADPCM_IMA_EA_EACS
@ AV_CODEC_ID_ADPCM_IMA_EA_EACS
Definition codec_id.h:394
AV_CODEC_ID_ADPCM_SBPRO_2
@ AV_CODEC_ID_ADPCM_SBPRO_2
Definition codec_id.h:387
AV_CODEC_ID_ADPCM_DTK
@ AV_CODEC_ID_ADPCM_DTK
Definition codec_id.h:403
AV_CODEC_ID_ADPCM_CIRCUS
@ AV_CODEC_ID_ADPCM_CIRCUS
Definition codec_id.h:430
AV_CODEC_ID_ADPCM_IMA_EA_SEAD
@ AV_CODEC_ID_ADPCM_IMA_EA_SEAD
Definition codec_id.h:393
AV_CODEC_ID_ADPCM_IMA_HVQM2
@ AV_CODEC_ID_ADPCM_IMA_HVQM2
Definition codec_id.h:427
AV_CODEC_ID_ADPCM_PSX
@ AV_CODEC_ID_ADPCM_PSX
Definition codec_id.h:407
AV_CODEC_ID_ADPCM_XA
@ AV_CODEC_ID_ADPCM_XA
Definition codec_id.h:378
AV_CODEC_ID_ADPCM_YAMAHA
@ AV_CODEC_ID_ADPCM_YAMAHA
Definition codec_id.h:384
AV_CODEC_ID_ADPCM_SBPRO_3
@ AV_CODEC_ID_ADPCM_SBPRO_3
Definition codec_id.h:386
AV_CODEC_ID_ADPCM_IMA_ESCAPE
@ AV_CODEC_ID_ADPCM_IMA_ESCAPE
Definition codec_id.h:431
AV_CODEC_ID_ADPCM_EA_R2
@ AV_CODEC_ID_ADPCM_EA_R2
Definition codec_id.h:392
AV_CODEC_ID_ADPCM_IMA_ISS
@ AV_CODEC_ID_ADPCM_IMA_ISS
Definition codec_id.h:397
AV_CODEC_ID_ADPCM_MS
@ AV_CODEC_ID_ADPCM_MS
Definition codec_id.h:376
AV_CODEC_ID_ADPCM_ZORK
@ AV_CODEC_ID_ADPCM_ZORK
Definition codec_id.h:414
AV_CODEC_ID_ADPCM_SBPRO_4
@ AV_CODEC_ID_ADPCM_SBPRO_4
Definition codec_id.h:385
AV_CODEC_ID_ADPCM_EA_MAXIS_XA
@ AV_CODEC_ID_ADPCM_EA_MAXIS_XA
Definition codec_id.h:396
AV_CODEC_ID_ADPCM_ARGO
@ AV_CODEC_ID_ADPCM_ARGO
Definition codec_id.h:412
AV_CODEC_ID_ADPCM_IMA_APC
@ AV_CODEC_ID_ADPCM_IMA_APC
Definition codec_id.h:399
AV_CODEC_ID_ADPCM_IMA_AMV
@ AV_CODEC_ID_ADPCM_IMA_AMV
Definition codec_id.h:389
AV_CODEC_ID_ADPCM_EA_XAS
@ AV_CODEC_ID_ADPCM_EA_XAS
Definition codec_id.h:395
AV_CODEC_ID_ADPCM_IMA_MAGIX
@ AV_CODEC_ID_ADPCM_IMA_MAGIX
Definition codec_id.h:428
AV_CODEC_ID_ADPCM_AGM
@ AV_CODEC_ID_ADPCM_AGM
Definition codec_id.h:411
AV_CODEC_ID_ADPCM_IMA_CUNNING
@ AV_CODEC_ID_ADPCM_IMA_CUNNING
Definition codec_id.h:418
AV_CODEC_ID_ADPCM_IMA_DK4
@ AV_CODEC_ID_ADPCM_IMA_DK4
Definition codec_id.h:373
AV_CODEC_ID_ADPCM_IMA_DK3
@ AV_CODEC_ID_ADPCM_IMA_DK3
Definition codec_id.h:372
AV_CODEC_ID_ADPCM_IMA_DAT4
@ AV_CODEC_ID_ADPCM_IMA_DAT4
Definition codec_id.h:409
AV_CODEC_ID_ADPCM_XMD
@ AV_CODEC_ID_ADPCM_XMD
Definition codec_id.h:421
AV_CODEC_ID_ADPCM_IMA_QT
@ AV_CODEC_ID_ADPCM_IMA_QT
Definition codec_id.h:370
AV_CODEC_ID_ADPCM_EA
@ AV_CODEC_ID_ADPCM_EA
Definition codec_id.h:380
AV_CODEC_ID_ADPCM_IMA_SMJPEG
@ AV_CODEC_ID_ADPCM_IMA_SMJPEG
Definition codec_id.h:375
AV_CODEC_ID_ADPCM_MTAF
@ AV_CODEC_ID_ADPCM_MTAF
Definition codec_id.h:410
AV_CODEC_ID_ADPCM_AICA
@ AV_CODEC_ID_ADPCM_AICA
Definition codec_id.h:408
AV_CODEC_ID_ADPCM_IMA_MTF
@ AV_CODEC_ID_ADPCM_IMA_MTF
Definition codec_id.h:417
AV_CODEC_ID_ADPCM_IMA_APM
@ AV_CODEC_ID_ADPCM_IMA_APM
Definition codec_id.h:415
AV_CODEC_ID_ADPCM_THP
@ AV_CODEC_ID_ADPCM_THP
Definition codec_id.h:388
AV_CODEC_ID_ADPCM_IMA_XBOX
@ AV_CODEC_ID_ADPCM_IMA_XBOX
Definition codec_id.h:422
AV_CODEC_ID_ADPCM_IMA_ACORN
@ AV_CODEC_ID_ADPCM_IMA_ACORN
Definition codec_id.h:420
AV_CODEC_ID_ADPCM_AFC
@ AV_CODEC_ID_ADPCM_AFC
Definition codec_id.h:401
AV_CODEC_ID_ADPCM_IMA_WAV
@ AV_CODEC_ID_ADPCM_IMA_WAV
Definition codec_id.h:371
AV_CODEC_ID_ADPCM_THP_LE
@ AV_CODEC_ID_ADPCM_THP_LE
Definition codec_id.h:406
AV_CODEC_ID_ADPCM_N64
@ AV_CODEC_ID_ADPCM_N64
Definition codec_id.h:426
AV_CODEC_ID_ADPCM_IMA_ALP
@ AV_CODEC_ID_ADPCM_IMA_ALP
Definition codec_id.h:416
AV_CODEC_ID_ADPCM_EA_R3
@ AV_CODEC_ID_ADPCM_EA_R3
Definition codec_id.h:391
AV_CODEC_ID_ADPCM_PSXC
@ AV_CODEC_ID_ADPCM_PSXC
Definition codec_id.h:429
AV_CODEC_ID_ADPCM_SANYO
@ AV_CODEC_ID_ADPCM_SANYO
Definition codec_id.h:423
AV_CODEC_ID_ADPCM_IMA_RAD
@ AV_CODEC_ID_ADPCM_IMA_RAD
Definition codec_id.h:404
AV_CODEC_ID_ADPCM_IMA_SSI
@ AV_CODEC_ID_ADPCM_IMA_SSI
Definition codec_id.h:413
AV_CODEC_ID_ADPCM_IMA_MOFLEX
@ AV_CODEC_ID_ADPCM_IMA_MOFLEX
Definition codec_id.h:419
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition error.h:64
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition error.h:61
AVERROR
#define AVERROR(e)
Definition error.h:45
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition samplefmt.h:64
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition samplefmt.h:58
index
int index
Definition gxfenc.c:90
for
for(k=2;k<=8;++k)
Definition h264pred_template.c:424
if
if(svq3)
Definition h264pred_template.c:429
offsets
static const int offsets[]
Definition hevc_pel.c:34
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition intra.c:278
AV_RL32
#define AV_RL32(p)
Definition intreadwrite.h:419
AV_RL16
#define AV_RL16(p)
Definition intreadwrite.h:405
shift
static int shift(int a, int b)
Definition bonk.c:261
attributes.h
Macro definitions for various function/variable attributes.
av_cold
#define av_cold
Definition attributes.h:117
FFMIN
#define FFMIN(a, b)
Definition macros.h:49
FFMAX
#define FFMAX(a, b)
Definition macros.h:47
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition mathops.h:135
bps
unsigned bps
Definition movenc.c:2074
table
static const uint16_t table[]
Definition prosumer.c:203
header
static const uint8_t header[24]
Definition sdr2.c:68
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition sinewin_tablegen.c:29
pred
static const float pred[4]
Definition siprdata.h:259
code
const uint8_t * code
Definition spdifenc.c:433
ADPCMChannelStatus::step_index
int16_t step_index
Definition adpcm.h:33
ADPCMDecodeContext::vqa_version
int vqa_version
VQA version.
Definition adpcm.c:248
ADPCMDecodeContext::status
ADPCMChannelStatus status[14]
Definition adpcm.c:247
ADPCMDecodeContext::has_status
int has_status
Status flag.
Definition adpcm.c:249
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition channel_layout.h:329
AVCodecContext
main external API structure.
Definition avcodec.h:443
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition avcodec.h:1055
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition avcodec.h:1047
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition avcodec.h:1564
AVCodecContext::codec
const struct AVCodec * codec
Definition avcodec.h:452
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition avcodec.h:526
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition avcodec.h:453
AVCodecContext::extradata_size
int extradata_size
Definition avcodec.h:527
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition avcodec.h:1075
AVCodecContext::priv_data
void * priv_data
Definition avcodec.h:470
AVCodec::id
enum AVCodecID id
Definition codec.h:189
AVFrame
This structure describes decoded (raw) audio or video data.
Definition frame.h:472
AVPacket
This structure stores compressed data.
Definition packet.h:580
AVPacket::size
int size
Definition packet.h:604
AVPacket::data
uint8_t * data
Definition packet.h:603
level
uint8_t level
Definition svq3.c:208
avpriv_request_sample
#define avpriv_request_sample(...)
Definition tableprint_vlc.h:37
av_log
#define av_log(a,...)
Definition tableprint_vlc.h:27
tmp
static uint8_t tmp[40]
Definition aes_ctr.c:52
filter
void(* filter)(uint8_t *src, ptrdiff_t stride, int qscale)
Definition h263dsp.c:29
size
int size
Definition twinvq_data.h:10344
g
const char * g
Definition vf_curves.c:128
temp
else temp
Definition vf_mcdeint.c:275
coeff
static const double coeff[2][5]
Definition vf_owdenoise.c:80
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition vf_paletteuse.c:166
delta
float delta
Definition vorbis_enc_data.h:430
c
static double c[64]
Definition vsrc_mptestsrc.c:89
Generated on Tue Aug 18 2026 20:20:49 for FFmpeg by doxygen 1.13.2