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