FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/adpcm.c
Date: 2023-06-04 16:45:34
Exec Total Coverage
Lines: 554 728 76.1%
Functions: 16 21 76.2%
Branches: 447 678 65.9%

Line Branch Exec Source
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 *
21 * This file is part of FFmpeg.
22 *
23 * FFmpeg is free software; you can redistribute it and/or
24 * modify it under the terms of the GNU Lesser General Public
25 * License as published by the Free Software Foundation; either
26 * version 2.1 of the License, or (at your option) any later version.
27 *
28 * FFmpeg is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
31 * Lesser General Public License for more details.
32 *
33 * You should have received a copy of the GNU Lesser General Public
34 * License along with FFmpeg; if not, write to the Free Software
35 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
36 */
37
38 #include "config_components.h"
39
40 #include "avcodec.h"
41 #include "get_bits.h"
42 #include "bytestream.h"
43 #include "adpcm.h"
44 #include "adpcm_data.h"
45 #include "codec_internal.h"
46 #include "decode.h"
47
48 /**
49 * @file
50 * ADPCM decoders
51 * Features and limitations:
52 *
53 * Reference documents:
54 * http://wiki.multimedia.cx/index.php?title=Category:ADPCM_Audio_Codecs
55 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html [dead]
56 * http://www.geocities.com/SiliconValley/8682/aud3.txt [dead]
57 * http://openquicktime.sourceforge.net/
58 * XAnim sources (xa_codec.c) http://xanim.polter.net/
59 * http://www.cs.ucla.edu/~leec/mediabench/applications.html [dead]
60 * SoX source code http://sox.sourceforge.net/
61 *
62 * CD-ROM XA:
63 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html [dead]
64 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html [dead]
65 * readstr http://www.geocities.co.jp/Playtown/2004/
66 */
67
68 #define CASE_0(codec_id, ...)
69 #define CASE_1(codec_id, ...) \
70 case codec_id: \
71 { __VA_ARGS__ } \
72 break;
73 #define CASE_2(enabled, codec_id, ...) \
74 CASE_ ## enabled(codec_id, __VA_ARGS__)
75 #define CASE_3(config, codec_id, ...) \
76 CASE_2(config, codec_id, __VA_ARGS__)
77 #define CASE(codec, ...) \
78 CASE_3(CONFIG_ ## codec ## _DECODER, AV_CODEC_ID_ ## codec, __VA_ARGS__)
79
80 /* These are for CD-ROM XA ADPCM */
81 static const int8_t xa_adpcm_table[5][2] = {
82 { 0, 0 },
83 { 60, 0 },
84 { 115, -52 },
85 { 98, -55 },
86 { 122, -60 }
87 };
88
89 static const int16_t afc_coeffs[2][16] = {
90 { 0, 2048, 0, 1024, 4096, 3584, 3072, 4608, 4200, 4800, 5120, 2048, 1024, -1024, -1024, -2048 },
91 { 0, 0, 2048, 1024, -2048, -1536, -1024, -2560, -2248, -2300, -3072, -2048, -1024, 1024, 0, 0 }
92 };
93
94 static const int16_t ea_adpcm_table[] = {
95 0, 240, 460, 392,
96 0, 0, -208, -220,
97 0, 1, 3, 4,
98 7, 8, 10, 11,
99 0, -1, -3, -4
100 };
101
102 /*
103 * Dumped from the binaries:
104 * - FantasticJourney.exe - 0x794D2, DGROUP:0x47A4D2
105 * - BigRaceUSA.exe - 0x9B8AA, DGROUP:0x49C4AA
106 * - Timeshock!.exe - 0x8506A, DGROUP:0x485C6A
107 */
108 static const int8_t ima_cunning_index_table[9] = {
109 -1, -1, -1, -1, 1, 2, 3, 4, -1
110 };
111
112 /*
113 * Dumped from the binaries:
114 * - FantasticJourney.exe - 0x79458, DGROUP:0x47A458
115 * - BigRaceUSA.exe - 0x9B830, DGROUP:0x49C430
116 * - Timeshock!.exe - 0x84FF0, DGROUP:0x485BF0
117 */
118 static const int16_t ima_cunning_step_table[61] = {
119 1, 1, 1, 1, 2, 2, 3, 3, 4, 5,
120 6, 7, 8, 10, 12, 14, 16, 20, 24, 28,
121 32, 40, 48, 56, 64, 80, 96, 112, 128, 160,
122 192, 224, 256, 320, 384, 448, 512, 640, 768, 896,
123 1024, 1280, 1536, 1792, 2048, 2560, 3072, 3584, 4096, 5120,
124 6144, 7168, 8192, 10240, 12288, 14336, 16384, 20480, 24576, 28672, 0
125 };
126
127 static const int8_t adpcm_index_table2[4] = {
128 -1, 2,
129 -1, 2,
130 };
131
132 static const int8_t adpcm_index_table3[8] = {
133 -1, -1, 1, 2,
134 -1, -1, 1, 2,
135 };
136
137 static const int8_t adpcm_index_table5[32] = {
138 -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16,
139 -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16,
140 };
141
142 static const int8_t * const adpcm_index_tables[4] = {
143 &adpcm_index_table2[0],
144 &adpcm_index_table3[0],
145 &ff_adpcm_index_table[0],
146 &adpcm_index_table5[0],
147 };
148
149 static const int16_t mtaf_stepsize[32][16] = {
150 { 1, 5, 9, 13, 16, 20, 24, 28,
151 -1, -5, -9, -13, -16, -20, -24, -28, },
152 { 2, 6, 11, 15, 20, 24, 29, 33,
153 -2, -6, -11, -15, -20, -24, -29, -33, },
154 { 2, 7, 13, 18, 23, 28, 34, 39,
155 -2, -7, -13, -18, -23, -28, -34, -39, },
156 { 3, 9, 15, 21, 28, 34, 40, 46,
157 -3, -9, -15, -21, -28, -34, -40, -46, },
158 { 3, 11, 18, 26, 33, 41, 48, 56,
159 -3, -11, -18, -26, -33, -41, -48, -56, },
160 { 4, 13, 22, 31, 40, 49, 58, 67,
161 -4, -13, -22, -31, -40, -49, -58, -67, },
162 { 5, 16, 26, 37, 48, 59, 69, 80,
163 -5, -16, -26, -37, -48, -59, -69, -80, },
164 { 6, 19, 31, 44, 57, 70, 82, 95,
165 -6, -19, -31, -44, -57, -70, -82, -95, },
166 { 7, 22, 38, 53, 68, 83, 99, 114,
167 -7, -22, -38, -53, -68, -83, -99, -114, },
168 { 9, 27, 45, 63, 81, 99, 117, 135,
169 -9, -27, -45, -63, -81, -99, -117, -135, },
170 { 10, 32, 53, 75, 96, 118, 139, 161,
171 -10, -32, -53, -75, -96, -118, -139, -161, },
172 { 12, 38, 64, 90, 115, 141, 167, 193,
173 -12, -38, -64, -90, -115, -141, -167, -193, },
174 { 15, 45, 76, 106, 137, 167, 198, 228,
175 -15, -45, -76, -106, -137, -167, -198, -228, },
176 { 18, 54, 91, 127, 164, 200, 237, 273,
177 -18, -54, -91, -127, -164, -200, -237, -273, },
178 { 21, 65, 108, 152, 195, 239, 282, 326,
179 -21, -65, -108, -152, -195, -239, -282, -326, },
180 { 25, 77, 129, 181, 232, 284, 336, 388,
181 -25, -77, -129, -181, -232, -284, -336, -388, },
182 { 30, 92, 153, 215, 276, 338, 399, 461,
183 -30, -92, -153, -215, -276, -338, -399, -461, },
184 { 36, 109, 183, 256, 329, 402, 476, 549,
185 -36, -109, -183, -256, -329, -402, -476, -549, },
186 { 43, 130, 218, 305, 392, 479, 567, 654,
187 -43, -130, -218, -305, -392, -479, -567, -654, },
188 { 52, 156, 260, 364, 468, 572, 676, 780,
189 -52, -156, -260, -364, -468, -572, -676, -780, },
190 { 62, 186, 310, 434, 558, 682, 806, 930,
191 -62, -186, -310, -434, -558, -682, -806, -930, },
192 { 73, 221, 368, 516, 663, 811, 958, 1106,
193 -73, -221, -368, -516, -663, -811, -958, -1106, },
194 { 87, 263, 439, 615, 790, 966, 1142, 1318,
195 -87, -263, -439, -615, -790, -966, -1142, -1318, },
196 { 104, 314, 523, 733, 942, 1152, 1361, 1571,
197 -104, -314, -523, -733, -942, -1152, -1361, -1571, },
198 { 124, 374, 623, 873, 1122, 1372, 1621, 1871,
199 -124, -374, -623, -873, -1122, -1372, -1621, -1871, },
200 { 148, 445, 743, 1040, 1337, 1634, 1932, 2229,
201 -148, -445, -743, -1040, -1337, -1634, -1932, -2229, },
202 { 177, 531, 885, 1239, 1593, 1947, 2301, 2655,
203 -177, -531, -885, -1239, -1593, -1947, -2301, -2655, },
204 { 210, 632, 1053, 1475, 1896, 2318, 2739, 3161,
205 -210, -632, -1053, -1475, -1896, -2318, -2739, -3161, },
206 { 251, 753, 1255, 1757, 2260, 2762, 3264, 3766,
207 -251, -753, -1255, -1757, -2260, -2762, -3264, -3766, },
208 { 299, 897, 1495, 2093, 2692, 3290, 3888, 4486,
209 -299, -897, -1495, -2093, -2692, -3290, -3888, -4486, },
210 { 356, 1068, 1781, 2493, 3206, 3918, 4631, 5343,
211 -356, -1068, -1781, -2493, -3206, -3918, -4631, -5343, },
212 { 424, 1273, 2121, 2970, 3819, 4668, 5516, 6365,
213 -424, -1273, -2121, -2970, -3819, -4668, -5516, -6365, },
214 };
215
216 static const int16_t oki_step_table[49] = {
217 16, 17, 19, 21, 23, 25, 28, 31, 34, 37,
218 41, 45, 50, 55, 60, 66, 73, 80, 88, 97,
219 107, 118, 130, 143, 157, 173, 190, 209, 230, 253,
220 279, 307, 337, 371, 408, 449, 494, 544, 598, 658,
221 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552
222 };
223
224 // padded to zero where table size is less then 16
225 static const int8_t swf_index_tables[4][16] = {
226 /*2*/ { -1, 2 },
227 /*3*/ { -1, -1, 2, 4 },
228 /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },
229 /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }
230 };
231
232 static const int8_t zork_index_table[8] = {
233 -1, -1, -1, 1, 4, 7, 10, 12,
234 };
235
236 static const int8_t mtf_index_table[16] = {
237 8, 6, 4, 2, -1, -1, -1, -1,
238 -1, -1, -1, -1, 2, 4, 6, 8,
239 };
240
241 /* end of tables */
242
243 typedef struct ADPCMDecodeContext {
244 ADPCMChannelStatus status[14];
245 int vqa_version; /**< VQA version. Used for ADPCM_IMA_WS */
246 int has_status; /**< Status flag. Reset to 0 after a flush. */
247 } ADPCMDecodeContext;
248
249 static void adpcm_flush(AVCodecContext *avctx);
250
251 187 static av_cold int adpcm_decode_init(AVCodecContext * avctx)
252 {
253 187 ADPCMDecodeContext *c = avctx->priv_data;
254 187 unsigned int min_channels = 1;
255 187 unsigned int max_channels = 2;
256
257 187 adpcm_flush(avctx);
258
259
5/7
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 23 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 8 times.
✓ Branch 6 taken 145 times.
187 switch(avctx->codec->id) {
260 3 case AV_CODEC_ID_ADPCM_IMA_AMV:
261 3 max_channels = 1;
262 3 break;
263 8 case AV_CODEC_ID_ADPCM_DTK:
264 case AV_CODEC_ID_ADPCM_EA:
265 8 min_channels = 2;
266 8 break;
267 23 case AV_CODEC_ID_ADPCM_AFC:
268 case AV_CODEC_ID_ADPCM_EA_R1:
269 case AV_CODEC_ID_ADPCM_EA_R2:
270 case AV_CODEC_ID_ADPCM_EA_R3:
271 case AV_CODEC_ID_ADPCM_EA_XAS:
272 case AV_CODEC_ID_ADPCM_MS:
273 23 max_channels = 6;
274 23 break;
275 case AV_CODEC_ID_ADPCM_MTAF:
276 min_channels = 2;
277 max_channels = 8;
278 if (avctx->ch_layout.nb_channels & 1) {
279 avpriv_request_sample(avctx, "channel count %d", avctx->ch_layout.nb_channels);
280 return AVERROR_PATCHWELCOME;
281 }
282 break;
283 case AV_CODEC_ID_ADPCM_PSX:
284 max_channels = 8;
285 if (avctx->ch_layout.nb_channels <= 0 ||
286 avctx->block_align % (16 * avctx->ch_layout.nb_channels))
287 return AVERROR_INVALIDDATA;
288 break;
289 8 case AV_CODEC_ID_ADPCM_IMA_DAT4:
290 case AV_CODEC_ID_ADPCM_THP:
291 case AV_CODEC_ID_ADPCM_THP_LE:
292 8 max_channels = 14;
293 8 break;
294 }
295
1/2
✓ Branch 0 taken 187 times.
✗ Branch 1 not taken.
187 if (avctx->ch_layout.nb_channels < min_channels ||
296
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 187 times.
187 avctx->ch_layout.nb_channels > max_channels) {
297 av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
298 return AVERROR(EINVAL);
299 }
300
301
3/4
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 171 times.
187 switch(avctx->codec->id) {
302 10 case AV_CODEC_ID_ADPCM_IMA_WAV:
303
2/4
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
10 if (avctx->bits_per_coded_sample < 2 || avctx->bits_per_coded_sample > 5)
304 return AVERROR_INVALIDDATA;
305 10 break;
306 6 case AV_CODEC_ID_ADPCM_ARGO:
307
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 if (avctx->bits_per_coded_sample != 4 ||
308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 avctx->block_align != 17 * avctx->ch_layout.nb_channels)
309 return AVERROR_INVALIDDATA;
310 6 break;
311 case AV_CODEC_ID_ADPCM_ZORK:
312 if (avctx->bits_per_coded_sample != 8)
313 return AVERROR_INVALIDDATA;
314 break;
315 171 default:
316 171 break;
317 }
318
319
4/4
✓ Branch 0 taken 87 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 81 times.
187 switch (avctx->codec->id) {
320 87 case AV_CODEC_ID_ADPCM_AICA:
321 case AV_CODEC_ID_ADPCM_IMA_CUNNING:
322 case AV_CODEC_ID_ADPCM_IMA_DAT4:
323 case AV_CODEC_ID_ADPCM_IMA_QT:
324 case AV_CODEC_ID_ADPCM_IMA_WAV:
325 case AV_CODEC_ID_ADPCM_4XM:
326 case AV_CODEC_ID_ADPCM_XA:
327 case AV_CODEC_ID_ADPCM_XMD:
328 case AV_CODEC_ID_ADPCM_EA_R1:
329 case AV_CODEC_ID_ADPCM_EA_R2:
330 case AV_CODEC_ID_ADPCM_EA_R3:
331 case AV_CODEC_ID_ADPCM_EA_XAS:
332 case AV_CODEC_ID_ADPCM_THP:
333 case AV_CODEC_ID_ADPCM_THP_LE:
334 case AV_CODEC_ID_ADPCM_AFC:
335 case AV_CODEC_ID_ADPCM_DTK:
336 case AV_CODEC_ID_ADPCM_PSX:
337 case AV_CODEC_ID_ADPCM_MTAF:
338 case AV_CODEC_ID_ADPCM_ARGO:
339 case AV_CODEC_ID_ADPCM_IMA_MOFLEX:
340 87 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
341 87 break;
342 8 case AV_CODEC_ID_ADPCM_IMA_WS:
343
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 6 times.
8 avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
344 AV_SAMPLE_FMT_S16;
345 8 break;
346 11 case AV_CODEC_ID_ADPCM_MS:
347
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
11 avctx->sample_fmt = avctx->ch_layout.nb_channels > 2 ? AV_SAMPLE_FMT_S16P :
348 AV_SAMPLE_FMT_S16;
349 11 break;
350 81 default:
351 81 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
352 }
353 187 return 0;
354 }
355
356 static inline int16_t adpcm_agm_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
357 {
358 int delta, pred, step, add;
359
360 pred = c->predictor;
361 delta = nibble & 7;
362 step = c->step;
363 add = (delta * 2 + 1) * step;
364 if (add < 0)
365 add = add + 7;
366
367 if ((nibble & 8) == 0)
368 pred = av_clip(pred + (add >> 3), -32767, 32767);
369 else
370 pred = av_clip(pred - (add >> 3), -32767, 32767);
371
372 switch (delta) {
373 case 7:
374 step *= 0x99;
375 break;
376 case 6:
377 c->step = av_clip(c->step * 2, 127, 24576);
378 c->predictor = pred;
379 return pred;
380 case 5:
381 step *= 0x66;
382 break;
383 case 4:
384 step *= 0x4d;
385 break;
386 default:
387 step *= 0x39;
388 break;
389 }
390
391 if (step < 0)
392 step += 0x3f;
393
394 c->step = step >> 6;
395 c->step = av_clip(c->step, 127, 24576);
396 c->predictor = pred;
397 return pred;
398 }
399
400 10314918 static inline int16_t adpcm_ima_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
401 {
402 int step_index;
403 int predictor;
404 int sign, delta, diff, step;
405
406 10314918 step = ff_adpcm_step_table[c->step_index];
407 10314918 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
408 10314918 step_index = av_clip(step_index, 0, 88);
409
410 10314918 sign = nibble & 8;
411 10314918 delta = nibble & 7;
412 /* perform direct multiplication instead of series of jumps proposed by
413 * the reference ADPCM implementation since modern CPUs can do the mults
414 * quickly enough */
415 10314918 diff = ((2 * delta + 1) * step) >> shift;
416 10314918 predictor = c->predictor;
417
2/2
✓ Branch 0 taken 5109700 times.
✓ Branch 1 taken 5205218 times.
10314918 if (sign) predictor -= diff;
418 5205218 else predictor += diff;
419
420 10314918 c->predictor = av_clip_int16(predictor);
421 10314918 c->step_index = step_index;
422
423 10314918 return (int16_t)c->predictor;
424 }
425
426 679344 static inline int16_t adpcm_ima_alp_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
427 {
428 int step_index;
429 int predictor;
430 int sign, delta, diff, step;
431
432 679344 step = ff_adpcm_step_table[c->step_index];
433 679344 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
434 679344 step_index = av_clip(step_index, 0, 88);
435
436 679344 sign = nibble & 8;
437 679344 delta = nibble & 7;
438 679344 diff = (delta * step) >> shift;
439 679344 predictor = c->predictor;
440
2/2
✓ Branch 0 taken 339842 times.
✓ Branch 1 taken 339502 times.
679344 if (sign) predictor -= diff;
441 339502 else predictor += diff;
442
443 679344 c->predictor = av_clip_int16(predictor);
444 679344 c->step_index = step_index;
445
446 679344 return (int16_t)c->predictor;
447 }
448
449 static inline int16_t adpcm_ima_mtf_expand_nibble(ADPCMChannelStatus *c, int nibble)
450 {
451 int step_index, step, delta, predictor;
452
453 step = ff_adpcm_step_table[c->step_index];
454
455 delta = step * (2 * nibble - 15);
456 predictor = c->predictor + delta;
457
458 step_index = c->step_index + mtf_index_table[(unsigned)nibble];
459 c->predictor = av_clip_int16(predictor >> 4);
460 c->step_index = av_clip(step_index, 0, 88);
461
462 return (int16_t)c->predictor;
463 }
464
465 386028 static inline int16_t adpcm_ima_cunning_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
466 {
467 int step_index;
468 int predictor;
469 int step;
470
471 386028 nibble = sign_extend(nibble & 0xF, 4);
472
473 386028 step = ima_cunning_step_table[c->step_index];
474 386028 step_index = c->step_index + ima_cunning_index_table[abs(nibble)];
475 386028 step_index = av_clip(step_index, 0, 60);
476
477 386028 predictor = c->predictor + step * nibble;
478
479 386028 c->predictor = av_clip_int16(predictor);
480 386028 c->step_index = step_index;
481
482 386028 return c->predictor;
483 }
484
485 static inline int16_t adpcm_ima_wav_expand_nibble(ADPCMChannelStatus *c, GetBitContext *gb, int bps)
486 {
487 int nibble, step_index, predictor, sign, delta, diff, step, shift;
488
489 shift = bps - 1;
490 nibble = get_bits_le(gb, bps),
491 step = ff_adpcm_step_table[c->step_index];
492 step_index = c->step_index + adpcm_index_tables[bps - 2][nibble];
493 step_index = av_clip(step_index, 0, 88);
494
495 sign = nibble & (1 << shift);
496 delta = av_mod_uintp2(nibble, shift);
497 diff = ((2 * delta + 1) * step) >> shift;
498 predictor = c->predictor;
499 if (sign) predictor -= diff;
500 else predictor += diff;
501
502 c->predictor = av_clip_int16(predictor);
503 c->step_index = step_index;
504
505 return (int16_t)c->predictor;
506 }
507
508 4696090 static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble)
509 {
510 int step_index;
511 int predictor;
512 int diff, step;
513
514 4696090 step = ff_adpcm_step_table[c->step_index];
515 4696090 step_index = c->step_index + ff_adpcm_index_table[nibble];
516 4696090 step_index = av_clip(step_index, 0, 88);
517
518 4696090 diff = step >> 3;
519
2/2
✓ Branch 0 taken 1076119 times.
✓ Branch 1 taken 3619971 times.
4696090 if (nibble & 4) diff += step;
520
2/2
✓ Branch 0 taken 1984447 times.
✓ Branch 1 taken 2711643 times.
4696090 if (nibble & 2) diff += step >> 1;
521
2/2
✓ Branch 0 taken 2159261 times.
✓ Branch 1 taken 2536829 times.
4696090 if (nibble & 1) diff += step >> 2;
522
523
2/2
✓ Branch 0 taken 2338238 times.
✓ Branch 1 taken 2357852 times.
4696090 if (nibble & 8)
524 2338238 predictor = c->predictor - diff;
525 else
526 2357852 predictor = c->predictor + diff;
527
528 4696090 c->predictor = av_clip_int16(predictor);
529 4696090 c->step_index = step_index;
530
531 4696090 return c->predictor;
532 }
533
534 2229948 static inline int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
535 {
536 int predictor;
537
538 2229948 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
539
2/2
✓ Branch 0 taken 972056 times.
✓ Branch 1 taken 1257892 times.
2229948 predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
540
541 2229948 c->sample2 = c->sample1;
542 2229948 c->sample1 = av_clip_int16(predictor);
543 2229948 c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
544
2/2
✓ Branch 0 taken 92703 times.
✓ Branch 1 taken 2137245 times.
2229948 if (c->idelta < 16) c->idelta = 16;
545
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2229948 times.
2229948 if (c->idelta > INT_MAX/768) {
546 av_log(NULL, AV_LOG_WARNING, "idelta overflow\n");
547 c->idelta = INT_MAX/768;
548 }
549
550 2229948 return c->sample1;
551 }
552
553 55124 static inline int16_t adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)
554 {
555 int step_index, predictor, sign, delta, diff, step;
556
557 55124 step = oki_step_table[c->step_index];
558 55124 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
559 55124 step_index = av_clip(step_index, 0, 48);
560
561 55124 sign = nibble & 8;
562 55124 delta = nibble & 7;
563 55124 diff = ((2 * delta + 1) * step) >> 3;
564 55124 predictor = c->predictor;
565
2/2
✓ Branch 0 taken 25352 times.
✓ Branch 1 taken 29772 times.
55124 if (sign) predictor -= diff;
566 29772 else predictor += diff;
567
568 55124 c->predictor = av_clip_intp2(predictor, 11);
569 55124 c->step_index = step_index;
570
571 55124 return c->predictor * 16;
572 }
573
574 524192 static inline int16_t adpcm_ct_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
575 {
576 int sign, delta, diff;
577 int new_step;
578
579 524192 sign = nibble & 8;
580 524192 delta = nibble & 7;
581 /* perform direct multiplication instead of series of jumps proposed by
582 * the reference ADPCM implementation since modern CPUs can do the mults
583 * quickly enough */
584 524192 diff = ((2 * delta + 1) * c->step) >> 3;
585 /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
586
2/2
✓ Branch 0 taken 263253 times.
✓ Branch 1 taken 260939 times.
524192 c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
587 524192 c->predictor = av_clip_int16(c->predictor);
588 /* calculate new step and clamp it to range 511..32767 */
589 524192 new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
590 524192 c->step = av_clip(new_step, 511, 32767);
591
592 524192 return (int16_t)c->predictor;
593 }
594
595 313380 static inline int16_t adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int size, int shift)
596 {
597 int sign, delta, diff;
598
599 313380 sign = nibble & (1<<(size-1));
600 313380 delta = nibble & ((1<<(size-1))-1);
601 313380 diff = delta << (7 + c->step + shift);
602
603 /* clamp result */
604
2/2
✓ Branch 0 taken 129904 times.
✓ Branch 1 taken 183476 times.
313380 c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
605
606 /* calculate new step */
607
4/4
✓ Branch 0 taken 97171 times.
✓ Branch 1 taken 216209 times.
✓ Branch 2 taken 75080 times.
✓ Branch 3 taken 22091 times.
313380 if (delta >= (2*size - 3) && c->step < 3)
608 75080 c->step++;
609
4/4
✓ Branch 0 taken 129907 times.
✓ Branch 1 taken 108393 times.
✓ Branch 2 taken 75080 times.
✓ Branch 3 taken 54827 times.
238300 else if (delta == 0 && c->step > 0)
610 75080 c->step--;
611
612 313380 return (int16_t) c->predictor;
613 }
614
615 1105920 static inline int16_t adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
616 {
617
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1105915 times.
1105920 if(!c->step) {
618 5 c->predictor = 0;
619 5 c->step = 127;
620 }
621
622 1105920 c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
623 1105920 c->predictor = av_clip_int16(c->predictor);
624 1105920 c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
625 1105920 c->step = av_clip(c->step, 127, 24576);
626 1105920 return c->predictor;
627 }
628
629 static inline int16_t adpcm_mtaf_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
630 {
631 c->predictor += mtaf_stepsize[c->step][nibble];
632 c->predictor = av_clip_int16(c->predictor);
633 c->step += ff_adpcm_index_table[nibble];
634 c->step = av_clip_uintp2(c->step, 5);
635 return c->predictor;
636 }
637
638 static inline int16_t adpcm_zork_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
639 {
640 int16_t index = c->step_index;
641 uint32_t lookup_sample = ff_adpcm_step_table[index];
642 int32_t sample = 0;
643
644 if (nibble & 0x40)
645 sample += lookup_sample;
646 if (nibble & 0x20)
647 sample += lookup_sample >> 1;
648 if (nibble & 0x10)
649 sample += lookup_sample >> 2;
650 if (nibble & 0x08)
651 sample += lookup_sample >> 3;
652 if (nibble & 0x04)
653 sample += lookup_sample >> 4;
654 if (nibble & 0x02)
655 sample += lookup_sample >> 5;
656 if (nibble & 0x01)
657 sample += lookup_sample >> 6;
658 if (nibble & 0x80)
659 sample = -sample;
660
661 sample += c->predictor;
662 sample = av_clip_int16(sample);
663
664 index += zork_index_table[(nibble >> 4) & 7];
665 index = av_clip(index, 0, 88);
666
667 c->predictor = sample;
668 c->step_index = index;
669
670 return sample;
671 }
672
673 666 static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
674 const uint8_t *in, ADPCMChannelStatus *left,
675 ADPCMChannelStatus *right, int channels, int sample_offset)
676 {
677 int i, j;
678 int shift,filter,f0,f1;
679 int s_1,s_2;
680 int d,s,t;
681
682 666 out0 += sample_offset;
683
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 666 times.
666 if (channels == 1)
684 out1 = out0 + 28;
685 else
686 666 out1 += sample_offset;
687
688
2/2
✓ Branch 0 taken 2664 times.
✓ Branch 1 taken 666 times.
3330 for(i=0;i<4;i++) {
689 2664 shift = 12 - (in[4+i*2] & 15);
690 2664 filter = in[4+i*2] >> 4;
691
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2664 times.
2664 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
692 avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
693 filter=0;
694 }
695
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2664 times.
2664 if (shift < 0) {
696 avpriv_request_sample(avctx, "unknown XA-ADPCM shift %d", shift);
697 shift = 0;
698 }
699 2664 f0 = xa_adpcm_table[filter][0];
700 2664 f1 = xa_adpcm_table[filter][1];
701
702 2664 s_1 = left->sample1;
703 2664 s_2 = left->sample2;
704
705
2/2
✓ Branch 0 taken 74592 times.
✓ Branch 1 taken 2664 times.
77256 for(j=0;j<28;j++) {
706 74592 d = in[16+i+j*4];
707
708 74592 t = sign_extend(d, 4);
709 74592 s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
710 74592 s_2 = s_1;
711 74592 s_1 = av_clip_int16(s);
712 74592 out0[j] = s_1;
713 }
714
715
1/2
✓ Branch 0 taken 2664 times.
✗ Branch 1 not taken.
2664 if (channels == 2) {
716 2664 left->sample1 = s_1;
717 2664 left->sample2 = s_2;
718 2664 s_1 = right->sample1;
719 2664 s_2 = right->sample2;
720 }
721
722 2664 shift = 12 - (in[5+i*2] & 15);
723 2664 filter = in[5+i*2] >> 4;
724
2/4
✓ Branch 0 taken 2664 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2664 times.
2664 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table) || shift < 0) {
725 avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
726 filter=0;
727 }
728
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2664 times.
2664 if (shift < 0) {
729 avpriv_request_sample(avctx, "unknown XA-ADPCM shift %d", shift);
730 shift = 0;
731 }
732
733 2664 f0 = xa_adpcm_table[filter][0];
734 2664 f1 = xa_adpcm_table[filter][1];
735
736
2/2
✓ Branch 0 taken 74592 times.
✓ Branch 1 taken 2664 times.
77256 for(j=0;j<28;j++) {
737 74592 d = in[16+i+j*4];
738
739 74592 t = sign_extend(d >> 4, 4);
740 74592 s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
741 74592 s_2 = s_1;
742 74592 s_1 = av_clip_int16(s);
743 74592 out1[j] = s_1;
744 }
745
746
1/2
✓ Branch 0 taken 2664 times.
✗ Branch 1 not taken.
2664 if (channels == 2) {
747 2664 right->sample1 = s_1;
748 2664 right->sample2 = s_2;
749 } else {
750 left->sample1 = s_1;
751 left->sample2 = s_2;
752 }
753
754 2664 out0 += 28 * (3 - channels);
755 2664 out1 += 28 * (3 - channels);
756 }
757
758 666 return 0;
759 }
760
761 195 static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
762 {
763 195 ADPCMDecodeContext *c = avctx->priv_data;
764 GetBitContext gb;
765 const int8_t *table;
766 195 int channels = avctx->ch_layout.nb_channels;
767 int k0, signmask, nb_bits, count;
768 195 int size = buf_size*8;
769 int i;
770
771 195 init_get_bits(&gb, buf, size);
772
773 //read bits & initial values
774 195 nb_bits = get_bits(&gb, 2)+2;
775 195 table = swf_index_tables[nb_bits-2];
776 195 k0 = 1 << (nb_bits-2);
777 195 signmask = 1 << (nb_bits-1);
778
779
2/2
✓ Branch 1 taken 195 times.
✓ Branch 2 taken 195 times.
390 while (get_bits_count(&gb) <= size - 22 * channels) {
780
2/2
✓ Branch 0 taken 390 times.
✓ Branch 1 taken 195 times.
585 for (i = 0; i < channels; i++) {
781 390 *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
782 390 c->status[i].step_index = get_bits(&gb, 6);
783 }
784
785
3/4
✓ Branch 1 taken 798525 times.
✓ Branch 2 taken 195 times.
✓ Branch 3 taken 798525 times.
✗ Branch 4 not taken.
798720 for (count = 0; get_bits_count(&gb) <= size - nb_bits * channels && count < 4095; count++) {
786 int i;
787
788
2/2
✓ Branch 0 taken 1597050 times.
✓ Branch 1 taken 798525 times.
2395575 for (i = 0; i < channels; i++) {
789 // similar to IMA adpcm
790 1597050 int delta = get_bits(&gb, nb_bits);
791 1597050 int step = ff_adpcm_step_table[c->status[i].step_index];
792 1597050 int vpdiff = 0; // vpdiff = (delta+0.5)*step/4
793 1597050 int k = k0;
794
795 do {
796
2/2
✓ Branch 0 taken 1979561 times.
✓ Branch 1 taken 2811589 times.
4791150 if (delta & k)
797 1979561 vpdiff += step;
798 4791150 step >>= 1;
799 4791150 k >>= 1;
800
2/2
✓ Branch 0 taken 3194100 times.
✓ Branch 1 taken 1597050 times.
4791150 } while(k);
801 1597050 vpdiff += step;
802
803
2/2
✓ Branch 0 taken 803527 times.
✓ Branch 1 taken 793523 times.
1597050 if (delta & signmask)
804 803527 c->status[i].predictor -= vpdiff;
805 else
806 793523 c->status[i].predictor += vpdiff;
807
808 1597050 c->status[i].step_index += table[delta & (~signmask)];
809
810 1597050 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
811 1597050 c->status[i].predictor = av_clip_int16(c->status[i].predictor);
812
813 1597050 *samples++ = c->status[i].predictor;
814 }
815 }
816 }
817 195 }
818
819 18335520 int16_t ff_adpcm_argo_expand_nibble(ADPCMChannelStatus *cs, int nibble, int shift, int flag)
820 {
821 18335520 int sample = sign_extend(nibble, 4) * (1 << shift);
822
823
2/2
✓ Branch 0 taken 9806208 times.
✓ Branch 1 taken 8529312 times.
18335520 if (flag)
824 9806208 sample += (8 * cs->sample1) - (4 * cs->sample2);
825 else
826 8529312 sample += 4 * cs->sample1;
827
828 18335520 sample = av_clip_int16(sample >> 2);
829
830 18335520 cs->sample2 = cs->sample1;
831 18335520 cs->sample1 = sample;
832
833 18335520 return sample;
834 }
835
836 /**
837 * Get the number of samples (per channel) that will be decoded from the packet.
838 * In one case, this is actually the maximum number of samples possible to
839 * decode with the given buf_size.
840 *
841 * @param[out] coded_samples set to the number of samples as coded in the
842 * packet, or 0 if the codec does not encode the
843 * number of samples in each frame.
844 * @param[out] approx_nb_samples set to non-zero if the number of samples
845 * returned is an approximation.
846 */
847 37569 static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
848 int buf_size, int *coded_samples, int *approx_nb_samples)
849 {
850 37569 ADPCMDecodeContext *s = avctx->priv_data;
851 37569 int nb_samples = 0;
852 37569 int ch = avctx->ch_layout.nb_channels;
853 37569 int has_coded_samples = 0;
854 int header_size;
855
856 37569 *coded_samples = 0;
857 37569 *approx_nb_samples = 0;
858
859
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37569 times.
37569 if(ch <= 0)
860 return 0;
861
862
4/4
✓ Branch 0 taken 600 times.
✓ Branch 1 taken 26342 times.
✓ Branch 2 taken 1084 times.
✓ Branch 3 taken 9543 times.
37569 switch (avctx->codec->id) {
863 /* constant, only check buf_size */
864 600 case AV_CODEC_ID_ADPCM_EA_XAS:
865
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 600 times.
600 if (buf_size < 76 * ch)
866 return 0;
867 600 nb_samples = 128;
868 600 break;
869 26342 case AV_CODEC_ID_ADPCM_IMA_QT:
870
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26342 times.
26342 if (buf_size < 34 * ch)
871 return 0;
872 26342 nb_samples = 64;
873 26342 break;
874 /* simple 4-bit adpcm */
875 1084 case AV_CODEC_ID_ADPCM_CT:
876 case AV_CODEC_ID_ADPCM_IMA_APC:
877 case AV_CODEC_ID_ADPCM_IMA_CUNNING:
878 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
879 case AV_CODEC_ID_ADPCM_IMA_OKI:
880 case AV_CODEC_ID_ADPCM_IMA_WS:
881 case AV_CODEC_ID_ADPCM_YAMAHA:
882 case AV_CODEC_ID_ADPCM_AICA:
883 case AV_CODEC_ID_ADPCM_IMA_SSI:
884 case AV_CODEC_ID_ADPCM_IMA_APM:
885 case AV_CODEC_ID_ADPCM_IMA_ALP:
886 case AV_CODEC_ID_ADPCM_IMA_MTF:
887 1084 nb_samples = buf_size * 2 / ch;
888 1084 break;
889 }
890
2/2
✓ Branch 0 taken 28026 times.
✓ Branch 1 taken 9543 times.
37569 if (nb_samples)
891 28026 return nb_samples;
892
893 /* simple 4-bit adpcm, with header */
894 9543 header_size = 0;
895
3/3
✓ Branch 0 taken 145 times.
✓ Branch 1 taken 350 times.
✓ Branch 2 taken 9048 times.
9543 switch (avctx->codec->id) {
896 145 case AV_CODEC_ID_ADPCM_4XM:
897 case AV_CODEC_ID_ADPCM_AGM:
898 case AV_CODEC_ID_ADPCM_IMA_ACORN:
899 case AV_CODEC_ID_ADPCM_IMA_DAT4:
900 case AV_CODEC_ID_ADPCM_IMA_MOFLEX:
901 145 case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;
902 350 case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4 * ch; break;
903 }
904
2/2
✓ Branch 0 taken 495 times.
✓ Branch 1 taken 9048 times.
9543 if (header_size > 0)
905 495 return (buf_size - header_size) * 2 / ch;
906
907 /* more complex formats */
908
17/21
✓ Branch 0 taken 161 times.
✓ Branch 1 taken 158 times.
✓ Branch 2 taken 47 times.
✓ Branch 3 taken 30 times.
✓ Branch 4 taken 400 times.
✓ Branch 5 taken 642 times.
✓ Branch 6 taken 649 times.
✓ Branch 7 taken 1000 times.
✓ Branch 8 taken 1668 times.
✓ Branch 9 taken 2943 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 57 times.
✓ Branch 12 taken 195 times.
✓ Branch 13 taken 71 times.
✓ Branch 14 taken 12 times.
✓ Branch 15 taken 37 times.
✗ Branch 16 not taken.
✓ Branch 17 taken 32 times.
✓ Branch 18 taken 946 times.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
9048 switch (avctx->codec->id) {
909 161 case AV_CODEC_ID_ADPCM_IMA_AMV:
910 161 bytestream2_skip(gb, 4);
911 161 has_coded_samples = 1;
912 161 *coded_samples = bytestream2_get_le32u(gb);
913 161 nb_samples = FFMIN((buf_size - 8) * 2, *coded_samples);
914 161 bytestream2_seek(gb, -8, SEEK_CUR);
915 161 break;
916 158 case AV_CODEC_ID_ADPCM_EA:
917 158 has_coded_samples = 1;
918 158 *coded_samples = bytestream2_get_le32(gb);
919 158 *coded_samples -= *coded_samples % 28;
920 158 nb_samples = (buf_size - 12) / 30 * 28;
921 158 break;
922 47 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
923 47 has_coded_samples = 1;
924 47 *coded_samples = bytestream2_get_le32(gb);
925 47 nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
926 47 break;
927 30 case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
928 30 nb_samples = (buf_size - ch) / ch * 2;
929 30 break;
930 400 case AV_CODEC_ID_ADPCM_EA_R1:
931 case AV_CODEC_ID_ADPCM_EA_R2:
932 case AV_CODEC_ID_ADPCM_EA_R3:
933 /* maximum number of samples */
934 /* has internal offsets and a per-frame switch to signal raw 16-bit */
935 400 has_coded_samples = 1;
936
3/4
✓ Branch 0 taken 95 times.
✓ Branch 1 taken 180 times.
✓ Branch 2 taken 125 times.
✗ Branch 3 not taken.
400 switch (avctx->codec->id) {
937 95 case AV_CODEC_ID_ADPCM_EA_R1:
938 95 header_size = 4 + 9 * ch;
939 95 *coded_samples = bytestream2_get_le32(gb);
940 95 break;
941 180 case AV_CODEC_ID_ADPCM_EA_R2:
942 180 header_size = 4 + 5 * ch;
943 180 *coded_samples = bytestream2_get_le32(gb);
944 180 break;
945 125 case AV_CODEC_ID_ADPCM_EA_R3:
946 125 header_size = 4 + 5 * ch;
947 125 *coded_samples = bytestream2_get_be32(gb);
948 125 break;
949 }
950 400 *coded_samples -= *coded_samples % 28;
951 400 nb_samples = (buf_size - header_size) * 2 / ch;
952 400 nb_samples -= nb_samples % 28;
953 400 *approx_nb_samples = 1;
954 400 break;
955 642 case AV_CODEC_ID_ADPCM_IMA_DK3:
956
1/2
✓ Branch 0 taken 642 times.
✗ Branch 1 not taken.
642 if (avctx->block_align > 0)
957 642 buf_size = FFMIN(buf_size, avctx->block_align);
958 642 nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
959 642 break;
960 649 case AV_CODEC_ID_ADPCM_IMA_DK4:
961
1/2
✓ Branch 0 taken 649 times.
✗ Branch 1 not taken.
649 if (avctx->block_align > 0)
962 649 buf_size = FFMIN(buf_size, avctx->block_align);
963
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 649 times.
649 if (buf_size < 4 * ch)
964 return AVERROR_INVALIDDATA;
965 649 nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
966 649 break;
967 1000 case AV_CODEC_ID_ADPCM_IMA_RAD:
968
1/2
✓ Branch 0 taken 1000 times.
✗ Branch 1 not taken.
1000 if (avctx->block_align > 0)
969 1000 buf_size = FFMIN(buf_size, avctx->block_align);
970 1000 nb_samples = (buf_size - 4 * ch) * 2 / ch;
971 1000 break;
972
2/4
✓ Branch 0 taken 1668 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1668 times.
1668 CASE(ADPCM_IMA_WAV,
973 int bsize = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
974 int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
975 if (avctx->block_align > 0)
976 buf_size = FFMIN(buf_size, avctx->block_align);
977 if (buf_size < 4 * ch)
978 return AVERROR_INVALIDDATA;
979 nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;
980 ) /* End of CASE */
981 2943 case AV_CODEC_ID_ADPCM_MS:
982
1/2
✓ Branch 0 taken 2943 times.
✗ Branch 1 not taken.
2943 if (avctx->block_align > 0)
983 2943 buf_size = FFMIN(buf_size, avctx->block_align);
984 2943 nb_samples = (buf_size - 6 * ch) * 2 / ch;
985 2943 break;
986 case AV_CODEC_ID_ADPCM_MTAF:
987 if (avctx->block_align > 0)
988 buf_size = FFMIN(buf_size, avctx->block_align);
989 nb_samples = (buf_size - 16 * (ch / 2)) * 2 / ch;
990 break;
991 57 case AV_CODEC_ID_ADPCM_SBPRO_2:
992 case AV_CODEC_ID_ADPCM_SBPRO_3:
993 case AV_CODEC_ID_ADPCM_SBPRO_4:
994 {
995 int samples_per_byte;
996
3/4
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 18 times.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
57 switch (avctx->codec->id) {
997 13 case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
998 18 case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
999 26 case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
1000 }
1001
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 54 times.
57 if (!s->status[0].step_index) {
1002
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (buf_size < ch)
1003 return AVERROR_INVALIDDATA;
1004 3 nb_samples++;
1005 3 buf_size -= ch;
1006 }
1007 57 nb_samples += buf_size * samples_per_byte / ch;
1008 57 break;
1009 }
1010 195 case AV_CODEC_ID_ADPCM_SWF:
1011 {
1012 195 int buf_bits = buf_size * 8 - 2;
1013 195 int nbits = (bytestream2_get_byte(gb) >> 6) + 2;
1014 195 int block_hdr_size = 22 * ch;
1015 195 int block_size = block_hdr_size + nbits * ch * 4095;
1016 195 int nblocks = buf_bits / block_size;
1017 195 int bits_left = buf_bits - nblocks * block_size;
1018 195 nb_samples = nblocks * 4096;
1019
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 195 times.
195 if (bits_left >= block_hdr_size)
1020 nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
1021 195 break;
1022 }
1023 71 case AV_CODEC_ID_ADPCM_THP:
1024 case AV_CODEC_ID_ADPCM_THP_LE:
1025
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
71 if (avctx->extradata) {
1026 nb_samples = buf_size * 14 / (8 * ch);
1027 break;
1028 }
1029 71 has_coded_samples = 1;
1030 71 bytestream2_skip(gb, 4); // channel size
1031 142 *coded_samples = (avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE) ?
1032
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
142 bytestream2_get_le32(gb) :
1033 71 bytestream2_get_be32(gb);
1034 71 buf_size -= 8 + 36 * ch;
1035 71 buf_size /= ch;
1036 71 nb_samples = buf_size / 8 * 14;
1037
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
71 if (buf_size % 8 > 1)
1038 nb_samples += (buf_size % 8 - 1) * 2;
1039 71 *approx_nb_samples = 1;
1040 71 break;
1041 12 case AV_CODEC_ID_ADPCM_AFC:
1042 12 nb_samples = buf_size / (9 * ch) * 16;
1043 12 break;
1044 37 case AV_CODEC_ID_ADPCM_XA:
1045 37 nb_samples = (buf_size / 128) * 224 / ch;
1046 37 break;
1047 case AV_CODEC_ID_ADPCM_XMD:
1048 nb_samples = buf_size / (21 * ch) * 32;
1049 break;
1050 32 case AV_CODEC_ID_ADPCM_DTK:
1051 case AV_CODEC_ID_ADPCM_PSX:
1052 32 nb_samples = buf_size / (16 * ch) * 28;
1053 32 break;
1054 946 case AV_CODEC_ID_ADPCM_ARGO:
1055 946 nb_samples = buf_size / avctx->block_align * 32;
1056 946 break;
1057 case AV_CODEC_ID_ADPCM_ZORK:
1058 nb_samples = buf_size / ch;
1059 break;
1060 }
1061
1062 /* validate coded sample count */
1063
4/6
✓ Branch 0 taken 837 times.
✓ Branch 1 taken 8211 times.
✓ Branch 2 taken 837 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 837 times.
9048 if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
1064 return AVERROR_INVALIDDATA;
1065
1066 9048 return nb_samples;
1067 }
1068
1069 37569 static int adpcm_decode_frame(AVCodecContext *avctx, AVFrame *frame,
1070 int *got_frame_ptr, AVPacket *avpkt)
1071 {
1072 37569 const uint8_t *buf = avpkt->data;
1073 37569 int buf_size = avpkt->size;
1074 37569 ADPCMDecodeContext *c = avctx->priv_data;
1075 37569 int channels = avctx->ch_layout.nb_channels;
1076 int16_t *samples;
1077 int16_t **samples_p;
1078 int st; /* stereo */
1079 int nb_samples, coded_samples, approx_nb_samples, ret;
1080 GetByteContext gb;
1081
1082 37569 bytestream2_init(&gb, buf, buf_size);
1083 37569 nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);
1084
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37569 times.
37569 if (nb_samples <= 0) {
1085 av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
1086 return AVERROR_INVALIDDATA;
1087 }
1088
1089 /* get output buffer */
1090 37569 frame->nb_samples = nb_samples;
1091
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 37569 times.
37569 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1092 return ret;
1093 37569 samples = (int16_t *)frame->data[0];
1094 37569 samples_p = (int16_t **)frame->extended_data;
1095
1096 /* use coded_samples when applicable */
1097 /* it is always <= nb_samples, so the output buffer will be large enough */
1098
2/2
✓ Branch 0 taken 837 times.
✓ Branch 1 taken 36732 times.
37569 if (coded_samples) {
1099
3/4
✓ Branch 0 taken 366 times.
✓ Branch 1 taken 471 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 366 times.
837 if (!approx_nb_samples && coded_samples != nb_samples)
1100 av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
1101 837 frame->nb_samples = nb_samples = coded_samples;
1102 }
1103
1104 37569 st = channels == 2 ? 1 : 0;
1105
1106
32/43
✓ Branch 0 taken 26342 times.
✓ Branch 1 taken 1668 times.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2943 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 649 times.
✓ Branch 7 taken 642 times.
✓ Branch 8 taken 119 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 179 times.
✓ Branch 12 taken 127 times.
✓ Branch 13 taken 87 times.
✓ Branch 14 taken 85 times.
✓ Branch 15 taken 39 times.
✓ Branch 16 taken 7 times.
✓ Branch 17 taken 1000 times.
✓ Branch 18 taken 311 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 37 times.
✓ Branch 21 taken 47 times.
✓ Branch 22 taken 49 times.
✓ Branch 23 taken 158 times.
✓ Branch 24 taken 30 times.
✓ Branch 25 taken 400 times.
✓ Branch 26 taken 600 times.
✗ Branch 27 not taken.
✓ Branch 28 taken 161 times.
✓ Branch 29 taken 350 times.
✓ Branch 30 taken 64 times.
✓ Branch 31 taken 57 times.
✓ Branch 32 taken 195 times.
✓ Branch 33 taken 136 times.
✗ Branch 34 not taken.
✓ Branch 35 taken 12 times.
✓ Branch 36 taken 71 times.
✓ Branch 37 taken 32 times.
✗ Branch 38 not taken.
✓ Branch 39 taken 946 times.
✗ Branch 40 not taken.
✗ Branch 41 not taken.
✗ Branch 42 not taken.
37569 switch(avctx->codec->id) {
1107
10/12
✓ Branch 1 taken 43648 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 39464 times.
✓ Branch 4 taken 4184 times.
✓ Branch 5 taken 30 times.
✓ Branch 6 taken 43618 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 43648 times.
✓ Branch 13 taken 1396736 times.
✓ Branch 14 taken 43648 times.
✓ Branch 15 taken 43648 times.
✓ Branch 16 taken 26342 times.
1466726 CASE(ADPCM_IMA_QT,
1108 /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
1109 Channel data is interleaved per-chunk. */
1110 for (int channel = 0; channel < channels; channel++) {
1111 ADPCMChannelStatus *cs = &c->status[channel];
1112 int predictor;
1113 int step_index;
1114 /* (pppppp) (piiiiiii) */
1115
1116 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
1117 predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
1118 step_index = predictor & 0x7F;
1119 predictor &= ~0x7F;
1120
1121 if (cs->step_index == step_index) {
1122 int diff = predictor - cs->predictor;
1123 if (diff < 0)
1124 diff = - diff;
1125 if (diff > 0x7f)
1126 goto update;
1127 } else {
1128 update:
1129 cs->step_index = step_index;
1130 cs->predictor = predictor;
1131 }
1132
1133 if (cs->step_index > 88u){
1134 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1135 channel, cs->step_index);
1136 return AVERROR_INVALIDDATA;
1137 }
1138
1139 samples = samples_p[channel];
1140
1141 for (int m = 0; m < 64; m += 2) {
1142 int byte = bytestream2_get_byteu(&gb);
1143 samples[m ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F);
1144 samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4 );
1145 }
1146 }
1147 ) /* End of CASE */
1148
10/22
✗ Branch 2 not taken.
✓ Branch 3 taken 3336 times.
✓ Branch 5 taken 3336 times.
✓ Branch 6 taken 1668 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 1668 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✓ Branch 25 taken 1107936 times.
✓ Branch 26 taken 276984 times.
✓ Branch 27 taken 276984 times.
✓ Branch 28 taken 138492 times.
✓ Branch 29 taken 138492 times.
✓ Branch 30 taken 1668 times.
1528416 CASE(ADPCM_IMA_WAV,
1149 for (int i = 0; i < channels; i++) {
1150 ADPCMChannelStatus *cs = &c->status[i];
1151 cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
1152
1153 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1154 if (cs->step_index > 88u){
1155 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1156 i, cs->step_index);
1157 return AVERROR_INVALIDDATA;
1158 }
1159 }
1160
1161 if (avctx->bits_per_coded_sample != 4) {
1162 int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
1163 int block_size = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
1164 uint8_t temp[20 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
1165 GetBitContext g;
1166
1167 for (int n = 0; n < (nb_samples - 1) / samples_per_block; n++) {
1168 for (int i = 0; i < channels; i++) {
1169 ADPCMChannelStatus *cs = &c->status[i];
1170 samples = &samples_p[i][1 + n * samples_per_block];
1171 for (int j = 0; j < block_size; j++) {
1172 temp[j] = buf[4 * channels + block_size * n * channels +
1173 (j % 4) + (j / 4) * (channels * 4) + i * 4];
1174 }
1175 ret = init_get_bits8(&g, (const uint8_t *)&temp, block_size);
1176 if (ret < 0)
1177 return ret;
1178 for (int m = 0; m < samples_per_block; m++) {
1179 samples[m] = adpcm_ima_wav_expand_nibble(cs, &g,
1180 avctx->bits_per_coded_sample);
1181 }
1182 }
1183 }
1184 bytestream2_skip(&gb, avctx->block_align - channels * 4);
1185 } else {
1186 for (int n = 0; n < (nb_samples - 1) / 8; n++) {
1187 for (int i = 0; i < channels; i++) {
1188 ADPCMChannelStatus *cs = &c->status[i];
1189 samples = &samples_p[i][1 + n * 8];
1190 for (int m = 0; m < 8; m += 2) {
1191 int v = bytestream2_get_byteu(&gb);
1192 samples[m ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1193 samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
1194 }
1195 }
1196 }
1197 }
1198 ) /* End of CASE */
1199
9/10
✓ Branch 1 taken 52 times.
✓ Branch 2 taken 26 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 52 times.
✓ Branch 7 taken 52 times.
✓ Branch 8 taken 26 times.
✓ Branch 12 taken 38224 times.
✓ Branch 13 taken 52 times.
✓ Branch 14 taken 52 times.
✓ Branch 15 taken 26 times.
38406 CASE(ADPCM_4XM,
1200 for (int i = 0; i < channels; i++)
1201 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1202
1203 for (int i = 0; i < channels; i++) {
1204 c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1205 if (c->status[i].step_index > 88u) {
1206 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1207 i, c->status[i].step_index);
1208 return AVERROR_INVALIDDATA;
1209 }
1210 }
1211
1212 for (int i = 0; i < channels; i++) {
1213 ADPCMChannelStatus *cs = &c->status[i];
1214 samples = (int16_t *)frame->data[i];
1215 for (int n = nb_samples >> 1; n > 0; n--) {
1216 int v = bytestream2_get_byteu(&gb);
1217 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
1218 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 4);
1219 }
1220 }
1221 ) /* End of CASE */
1222 CASE(ADPCM_AGM,
1223 for (int i = 0; i < channels; i++)
1224 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1225 for (int i = 0; i < channels; i++)
1226 c->status[i].step = sign_extend(bytestream2_get_le16u(&gb), 16);
1227
1228 for (int n = 0; n < nb_samples >> (1 - st); n++) {
1229 int v = bytestream2_get_byteu(&gb);
1230 *samples++ = adpcm_agm_expand_nibble(&c->status[0], v & 0xF);
1231 *samples++ = adpcm_agm_expand_nibble(&c->status[st], v >> 4 );
1232 }
1233 ) /* End of CASE */
1234
17/26
✗ Branch 0 not taken.
✓ Branch 1 taken 2943 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 17 not taken.
✓ Branch 18 taken 2943 times.
✓ Branch 20 taken 2895 times.
✓ Branch 21 taken 48 times.
✗ Branch 23 not taken.
✓ Branch 24 taken 2895 times.
✓ Branch 27 taken 2895 times.
✓ Branch 28 taken 48 times.
✓ Branch 31 taken 2895 times.
✓ Branch 32 taken 48 times.
✓ Branch 35 taken 2895 times.
✓ Branch 36 taken 48 times.
✓ Branch 38 taken 2895 times.
✓ Branch 39 taken 48 times.
✓ Branch 40 taken 2895 times.
✓ Branch 41 taken 48 times.
✓ Branch 45 taken 1114974 times.
✓ Branch 46 taken 2943 times.
1117917 CASE(ADPCM_MS,
1235 int block_predictor;
1236
1237 if (avctx->ch_layout.nb_channels > 2) {
1238 for (int channel = 0; channel < avctx->ch_layout.nb_channels; channel++) {
1239 samples = samples_p[channel];
1240 block_predictor = bytestream2_get_byteu(&gb);
1241 if (block_predictor > 6) {
1242 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[%d] = %d\n",
1243 channel, block_predictor);
1244 return AVERROR_INVALIDDATA;
1245 }
1246 c->status[channel].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1247 c->status[channel].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1248 c->status[channel].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1249 c->status[channel].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1250 c->status[channel].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1251 *samples++ = c->status[channel].sample2;
1252 *samples++ = c->status[channel].sample1;
1253 for (int n = (nb_samples - 2) >> 1; n > 0; n--) {
1254 int byte = bytestream2_get_byteu(&gb);
1255 *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte >> 4 );
1256 *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte & 0x0F);
1257 }
1258 }
1259 } else {
1260 block_predictor = bytestream2_get_byteu(&gb);
1261 if (block_predictor > 6) {
1262 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
1263 block_predictor);
1264 return AVERROR_INVALIDDATA;
1265 }
1266 c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1267 c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1268 if (st) {
1269 block_predictor = bytestream2_get_byteu(&gb);
1270 if (block_predictor > 6) {
1271 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
1272 block_predictor);
1273 return AVERROR_INVALIDDATA;
1274 }
1275 c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1276 c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1277 }
1278 c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1279 if (st){
1280 c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1281 }
1282
1283 c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1284 if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1285 c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1286 if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1287
1288 *samples++ = c->status[0].sample2;
1289 if (st) *samples++ = c->status[1].sample2;
1290 *samples++ = c->status[0].sample1;
1291 if (st) *samples++ = c->status[1].sample1;
1292 for (int n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
1293 int byte = bytestream2_get_byteu(&gb);
1294 *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4 );
1295 *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
1296 }
1297 }
1298 ) /* End of CASE */
1299 CASE(ADPCM_MTAF,
1300 for (int channel = 0; channel < channels; channel += 2) {
1301 bytestream2_skipu(&gb, 4);
1302 c->status[channel ].step = bytestream2_get_le16u(&gb) & 0x1f;
1303 c->status[channel + 1].step = bytestream2_get_le16u(&gb) & 0x1f;
1304 c->status[channel ].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1305 bytestream2_skipu(&gb, 2);
1306 c->status[channel + 1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1307 bytestream2_skipu(&gb, 2);
1308 for (int n = 0; n < nb_samples; n += 2) {
1309 int v = bytestream2_get_byteu(&gb);
1310 samples_p[channel][n ] = adpcm_mtaf_expand_nibble(&c->status[channel], v & 0x0F);
1311 samples_p[channel][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel], v >> 4 );
1312 }
1313 for (int n = 0; n < nb_samples; n += 2) {
1314 int v = bytestream2_get_byteu(&gb);
1315 samples_p[channel + 1][n ] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v & 0x0F);
1316 samples_p[channel + 1][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v >> 4 );
1317 }
1318 }
1319 ) /* End of CASE */
1320
5/6
✗ Branch 2 not taken.
✓ Branch 3 taken 1298 times.
✓ Branch 5 taken 1298 times.
✓ Branch 6 taken 649 times.
✓ Branch 10 taken 1323960 times.
✓ Branch 11 taken 649 times.
1325907 CASE(ADPCM_IMA_DK4,
1321 for (int channel = 0; channel < channels; channel++) {
1322 ADPCMChannelStatus *cs = &c->status[channel];
1323 cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
1324 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1325 if (cs->step_index > 88u){
1326 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1327 channel, cs->step_index);
1328 return AVERROR_INVALIDDATA;
1329 }
1330 }
1331 for (int n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
1332 int v = bytestream2_get_byteu(&gb);
1333 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3);
1334 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1335 }
1336 ) /* End of CASE */
1337
1338 /* DK3 ADPCM support macro */
1339 #define DK3_GET_NEXT_NIBBLE() \
1340 if (decode_top_nibble_next) { \
1341 nibble = last_byte >> 4; \
1342 decode_top_nibble_next = 0; \
1343 } else { \
1344 last_byte = bytestream2_get_byteu(&gb); \
1345 nibble = last_byte & 0x0F; \
1346 decode_top_nibble_next = 1; \
1347 }
1348
11/14
✓ Branch 5 taken 642 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 642 times.
✓ Branch 10 taken 434634 times.
✓ Branch 11 taken 434634 times.
✓ Branch 14 taken 434634 times.
✓ Branch 15 taken 434634 times.
✓ Branch 18 taken 434634 times.
✓ Branch 19 taken 434634 times.
✓ Branch 22 taken 869268 times.
✓ Branch 23 taken 642 times.
✓ Branch 25 taken 642 times.
✗ Branch 26 not taken.
869910 CASE(ADPCM_IMA_DK3,
1349 int last_byte = 0;
1350 int nibble;
1351 int decode_top_nibble_next = 0;
1352 int diff_channel;
1353 const int16_t *samples_end = samples + channels * nb_samples;
1354
1355 bytestream2_skipu(&gb, 10);
1356 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1357 c->status[1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1358 c->status[0].step_index = bytestream2_get_byteu(&gb);
1359 c->status[1].step_index = bytestream2_get_byteu(&gb);
1360 if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
1361 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
1362 c->status[0].step_index, c->status[1].step_index);
1363 return AVERROR_INVALIDDATA;
1364 }
1365 /* sign extend the predictors */
1366 diff_channel = c->status[1].predictor;
1367
1368 while (samples < samples_end) {
1369
1370 /* for this algorithm, c->status[0] is the sum channel and
1371 * c->status[1] is the diff channel */
1372
1373 /* process the first predictor of the sum channel */
1374 DK3_GET_NEXT_NIBBLE();
1375 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1376
1377 /* process the diff channel predictor */
1378 DK3_GET_NEXT_NIBBLE();
1379 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
1380
1381 /* process the first pair of stereo PCM samples */
1382 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1383 *samples++ = c->status[0].predictor + c->status[1].predictor;
1384 *samples++ = c->status[0].predictor - c->status[1].predictor;
1385
1386 /* process the second predictor of the sum channel */
1387 DK3_GET_NEXT_NIBBLE();
1388 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1389
1390 /* process the second pair of stereo PCM samples */
1391 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1392 *samples++ = c->status[0].predictor + c->status[1].predictor;
1393 *samples++ = c->status[0].predictor - c->status[1].predictor;
1394 }
1395
1396 if ((bytestream2_tell(&gb) & 1))
1397 bytestream2_skip(&gb, 1);
1398 ) /* End of CASE */
1399
6/8
✗ Branch 2 not taken.
✓ Branch 3 taken 119 times.
✓ Branch 5 taken 119 times.
✓ Branch 6 taken 119 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 60452 times.
✓ Branch 12 taken 60452 times.
✓ Branch 13 taken 119 times.
60690 CASE(ADPCM_IMA_ISS,
1400 for (int channel = 0; channel < channels; channel++) {
1401 ADPCMChannelStatus *cs = &c->status[channel];
1402 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1403 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1404 if (cs->step_index > 88u){
1405 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1406 channel, cs->step_index);
1407 return AVERROR_INVALIDDATA;
1408 }
1409 }
1410
1411 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1412 int v1, v2;
1413 int v = bytestream2_get_byteu(&gb);
1414 /* nibbles are swapped for mono */
1415 if (st) {
1416 v1 = v >> 4;
1417 v2 = v & 0x0F;
1418 } else {
1419 v2 = v >> 4;
1420 v1 = v & 0x0F;
1421 }
1422 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
1423 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
1424 }
1425 ) /* End of CASE */
1426 CASE(ADPCM_IMA_MOFLEX,
1427 for (int channel = 0; channel < channels; channel++) {
1428 ADPCMChannelStatus *cs = &c->status[channel];
1429 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1430 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1431 if (cs->step_index > 88u){
1432 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1433 channel, cs->step_index);
1434 return AVERROR_INVALIDDATA;
1435 }
1436 }
1437
1438 for (int subframe = 0; subframe < nb_samples / 256; subframe++) {
1439 for (int channel = 0; channel < channels; channel++) {
1440 samples = samples_p[channel] + 256 * subframe;
1441 for (int n = 0; n < 256; n += 2) {
1442 int v = bytestream2_get_byteu(&gb);
1443 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1444 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1445 }
1446 }
1447 }
1448 ) /* End of CASE */
1449 CASE(ADPCM_IMA_DAT4,
1450 for (int channel = 0; channel < channels; channel++) {
1451 ADPCMChannelStatus *cs = &c->status[channel];
1452 samples = samples_p[channel];
1453 bytestream2_skip(&gb, 4);
1454 for (int n = 0; n < nb_samples; n += 2) {
1455 int v = bytestream2_get_byteu(&gb);
1456 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
1457 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1458 }
1459 }
1460 ) /* End of CASE */
1461
2/2
✓ Branch 3 taken 732060 times.
✓ Branch 4 taken 179 times.
732239 CASE(ADPCM_IMA_APC,
1462 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1463 int v = bytestream2_get_byteu(&gb);
1464 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
1465 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1466 }
1467 ) /* End of CASE */
1468
2/2
✓ Branch 3 taken 514600 times.
✓ Branch 4 taken 127 times.
514727 CASE(ADPCM_IMA_SSI,
1469 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1470 int v = bytestream2_get_byteu(&gb);
1471 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0], v >> 4 );
1472 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0x0F);
1473 }
1474 ) /* End of CASE */
1475
4/4
✓ Branch 3 taken 347109 times.
✓ Branch 4 taken 181830 times.
✓ Branch 5 taken 181830 times.
✓ Branch 6 taken 87 times.
529026 CASE(ADPCM_IMA_APM,
1476 for (int n = nb_samples / 2; n > 0; n--) {
1477 for (int channel = 0; channel < channels; channel++) {
1478 int v = bytestream2_get_byteu(&gb);
1479 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[channel], v >> 4 );
1480 samples[st] = adpcm_ima_qt_expand_nibble(&c->status[channel], v & 0x0F);
1481 }
1482 samples += channels;
1483 }
1484 ) /* End of CASE */
1485
4/4
✓ Branch 3 taken 339672 times.
✓ Branch 4 taken 172372 times.
✓ Branch 5 taken 172372 times.
✓ Branch 6 taken 85 times.
512129 CASE(ADPCM_IMA_ALP,
1486 for (int n = nb_samples / 2; n > 0; n--) {
1487 for (int channel = 0; channel < channels; channel++) {
1488 int v = bytestream2_get_byteu(&gb);
1489 *samples++ = adpcm_ima_alp_expand_nibble(&c->status[channel], v >> 4 , 2);
1490 samples[st] = adpcm_ima_alp_expand_nibble(&c->status[channel], v & 0x0F, 2);
1491 }
1492 samples += channels;
1493 }
1494 ) /* End of CASE */
1495
4/4
✓ Branch 3 taken 193014 times.
✓ Branch 4 taken 51 times.
✓ Branch 5 taken 51 times.
✓ Branch 6 taken 39 times.
193104 CASE(ADPCM_IMA_CUNNING,
1496 for (int channel = 0; channel < channels; channel++) {
1497 int16_t *smp = samples_p[channel];
1498 for (int n = 0; n < nb_samples / 2; n++) {
1499 int v = bytestream2_get_byteu(&gb);
1500 *smp++ = adpcm_ima_cunning_expand_nibble(&c->status[channel], v & 0x0F);
1501 *smp++ = adpcm_ima_cunning_expand_nibble(&c->status[channel], v >> 4);
1502 }
1503 }
1504 ) /* End of CASE */
1505
2/2
✓ Branch 3 taken 27562 times.
✓ Branch 4 taken 7 times.
27569 CASE(ADPCM_IMA_OKI,
1506 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1507 int v = bytestream2_get_byteu(&gb);
1508 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[0], v >> 4 );
1509 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[st], v & 0x0F);
1510 }
1511 ) /* End of CASE */
1512
10/12
✗ Branch 2 not taken.
✓ Branch 3 taken 2000 times.
✓ Branch 5 taken 2000 times.
✓ Branch 6 taken 1000 times.
✓ Branch 8 taken 16000 times.
✗ Branch 9 not taken.
✓ Branch 12 taken 32000 times.
✓ Branch 13 taken 16000 times.
✓ Branch 15 taken 32000 times.
✓ Branch 16 taken 16000 times.
✓ Branch 17 taken 16000 times.
✓ Branch 18 taken 1000 times.
83000 CASE(ADPCM_IMA_RAD,
1513 for (int channel = 0; channel < channels; channel++) {
1514 ADPCMChannelStatus *cs = &c->status[channel];
1515 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1516 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1517 if (cs->step_index > 88u){
1518 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1519 channel, cs->step_index);
1520 return AVERROR_INVALIDDATA;
1521 }
1522 }
1523 for (int n = 0; n < nb_samples / 2; n++) {
1524 int byte[2];
1525
1526 byte[0] = bytestream2_get_byteu(&gb);
1527 if (st)
1528 byte[1] = bytestream2_get_byteu(&gb);
1529 for (int channel = 0; channel < channels; channel++) {
1530 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] & 0x0F, 3);
1531 }
1532 for (int channel = 0; channel < channels; channel++) {
1533 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] >> 4 , 3);
1534 }
1535 }
1536 ) /* End of CASE */
1537
10/10
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 299 times.
✓ Branch 5 taken 8820 times.
✓ Branch 6 taken 12 times.
✓ Branch 7 taken 12 times.
✓ Branch 8 taken 12 times.
✓ Branch 12 taken 298777 times.
✓ Branch 13 taken 166477 times.
✓ Branch 14 taken 166477 times.
✓ Branch 15 taken 299 times.
474397 CASE(ADPCM_IMA_WS,
1538 if (c->vqa_version == 3) {
1539 for (int channel = 0; channel < channels; channel++) {
1540 int16_t *smp = samples_p[channel];
1541
1542 for (int n = nb_samples / 2; n > 0; n--) {
1543 int v = bytestream2_get_byteu(&gb);
1544 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1545 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1546 }
1547 }
1548 } else {
1549 for (int n = nb_samples / 2; n > 0; n--) {
1550 for (int channel = 0; channel < channels; channel++) {
1551 int v = bytestream2_get_byteu(&gb);
1552 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1553 samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1554 }
1555 samples += channels;
1556 }
1557 }
1558 bytestream2_seek(&gb, 0, SEEK_END);
1559 ) /* End of CASE */
1560 CASE(ADPCM_XMD,
1561 int bytes_remaining, block = 0;
1562 while (bytestream2_get_bytes_left(&gb) >= 21 * channels) {
1563 for (int channel = 0; channel < channels; channel++) {
1564 int16_t *out = samples_p[channel] + block * 32;
1565 int16_t history[2];
1566 uint16_t scale;
1567
1568 history[1] = sign_extend(bytestream2_get_le16(&gb), 16);
1569 history[0] = sign_extend(bytestream2_get_le16(&gb), 16);
1570 scale = bytestream2_get_le16(&gb);
1571
1572 out[0] = history[1];
1573 out[1] = history[0];
1574
1575 for (int n = 0; n < 15; n++) {
1576 unsigned byte = bytestream2_get_byte(&gb);
1577 int32_t nibble[2];
1578
1579 nibble[0] = sign_extend(byte & 15, 4);
1580 nibble[1] = sign_extend(byte >> 4, 4);
1581
1582 out[2+n*2] = nibble[0]*scale + ((history[0]*3667 - history[1]*1642) >> 11);
1583 history[1] = history[0];
1584 history[0] = out[2+n*2];
1585
1586 out[2+n*2+1] = nibble[1]*scale + ((history[0]*3667 - history[1]*1642) >> 11);
1587 history[1] = history[0];
1588 history[0] = out[2+n*2+1];
1589 }
1590 }
1591
1592 block++;
1593 }
1594 bytes_remaining = bytestream2_get_bytes_left(&gb);
1595 if (bytes_remaining > 0) {
1596 bytestream2_skip(&gb, bytes_remaining);
1597 }
1598 ) /* End of CASE */
1599
4/6
✗ Branch 2 not taken.
✓ Branch 3 taken 666 times.
✓ Branch 6 taken 666 times.
✓ Branch 7 taken 37 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 37 times.
703 CASE(ADPCM_XA,
1600 int16_t *out0 = samples_p[0];
1601 int16_t *out1 = samples_p[1];
1602 int samples_per_block = 28 * (3 - channels) * 4;
1603 int sample_offset = 0;
1604 int bytes_remaining;
1605 while (bytestream2_get_bytes_left(&gb) >= 128) {
1606 if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
1607 &c->status[0], &c->status[1],
1608 channels, sample_offset)) < 0)
1609 return ret;
1610 bytestream2_skipu(&gb, 128);
1611 sample_offset += samples_per_block;
1612 }
1613 /* Less than a full block of data left, e.g. when reading from
1614 * 2324 byte per sector XA; the remainder is padding */
1615 bytes_remaining = bytestream2_get_bytes_left(&gb);
1616 if (bytes_remaining > 0) {
1617 bytestream2_skip(&gb, bytes_remaining);
1618 }
1619 ) /* End of CASE */
1620
8/10
✗ Branch 1 not taken.
✓ Branch 2 taken 94 times.
✓ Branch 4 taken 94 times.
✓ Branch 5 taken 47 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 94 times.
✓ Branch 9 taken 94 times.
✓ Branch 10 taken 47 times.
✓ Branch 14 taken 68996 times.
✓ Branch 15 taken 47 times.
69231 CASE(ADPCM_IMA_EA_EACS,
1621 for (int i = 0; i <= st; i++) {
1622 c->status[i].step_index = bytestream2_get_le32u(&gb);
1623 if (c->status[i].step_index > 88u) {
1624 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1625 i, c->status[i].step_index);
1626 return AVERROR_INVALIDDATA;
1627 }
1628 }
1629 for (int i = 0; i <= st; i++) {
1630 c->status[i].predictor = bytestream2_get_le32u(&gb);
1631 if (FFABS((int64_t)c->status[i].predictor) > (1<<16))
1632 return AVERROR_INVALIDDATA;
1633 }
1634
1635 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1636 int byte = bytestream2_get_byteu(&gb);
1637 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 3);
1638 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
1639 }
1640 ) /* End of CASE */
1641
2/2
✓ Branch 3 taken 71392 times.
✓ Branch 4 taken 49 times.
71441 CASE(ADPCM_IMA_EA_SEAD,
1642 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1643 int byte = bytestream2_get_byteu(&gb);
1644 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);
1645 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
1646 }
1647 ) /* End of CASE */
1648
5/6
✗ Branch 0 not taken.
✓ Branch 1 taken 158 times.
✓ Branch 9 taken 232288 times.
✓ Branch 10 taken 8296 times.
✓ Branch 11 taken 8296 times.
✓ Branch 12 taken 158 times.
240742 CASE(ADPCM_EA,
1649 int previous_left_sample, previous_right_sample;
1650 int current_left_sample, current_right_sample;
1651 int next_left_sample, next_right_sample;
1652 int coeff1l, coeff2l, coeff1r, coeff2r;
1653 int shift_left, shift_right;
1654
1655 /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
1656 each coding 28 stereo samples. */
1657
1658 if (channels != 2)
1659 return AVERROR_INVALIDDATA;
1660
1661 current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1662 previous_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1663 current_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1664 previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1665
1666 for (int count1 = 0; count1 < nb_samples / 28; count1++) {
1667 int byte = bytestream2_get_byteu(&gb);
1668 coeff1l = ea_adpcm_table[ byte >> 4 ];
1669 coeff2l = ea_adpcm_table[(byte >> 4 ) + 4];
1670 coeff1r = ea_adpcm_table[ byte & 0x0F];
1671 coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];
1672
1673 byte = bytestream2_get_byteu(&gb);
1674 shift_left = 20 - (byte >> 4);
1675 shift_right = 20 - (byte & 0x0F);
1676
1677 for (int count2 = 0; count2 < 28; count2++) {
1678 byte = bytestream2_get_byteu(&gb);
1679 next_left_sample = sign_extend(byte >> 4, 4) * (1 << shift_left);
1680 next_right_sample = sign_extend(byte, 4) * (1 << shift_right);
1681
1682 next_left_sample = (next_left_sample +
1683 (current_left_sample * coeff1l) +
1684 (previous_left_sample * coeff2l) + 0x80) >> 8;
1685 next_right_sample = (next_right_sample +
1686 (current_right_sample * coeff1r) +
1687 (previous_right_sample * coeff2r) + 0x80) >> 8;
1688
1689 previous_left_sample = current_left_sample;
1690 current_left_sample = av_clip_int16(next_left_sample);
1691 previous_right_sample = current_right_sample;
1692 current_right_sample = av_clip_int16(next_right_sample);
1693 *samples++ = current_left_sample;
1694 *samples++ = current_right_sample;
1695 }
1696 }
1697
1698 bytestream2_skip(&gb, 2); // Skip terminating 0x0000
1699 ) /* End of CASE */
1700
11/12
✓ Branch 1 taken 120 times.
✓ Branch 2 taken 60 times.
✓ Branch 3 taken 60 times.
✓ Branch 4 taken 30 times.
✓ Branch 6 taken 420 times.
✗ Branch 7 not taken.
✓ Branch 9 taken 1680 times.
✓ Branch 10 taken 840 times.
✓ Branch 11 taken 840 times.
✓ Branch 12 taken 420 times.
✓ Branch 13 taken 420 times.
✓ Branch 14 taken 30 times.
3150 CASE(ADPCM_EA_MAXIS_XA,
1701 int coeff[2][2], shift[2];
1702
1703 for (int channel = 0; channel < channels; channel++) {
1704 int byte = bytestream2_get_byteu(&gb);
1705 for (int i = 0; i < 2; i++)
1706 coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
1707 shift[channel] = 20 - (byte & 0x0F);
1708 }
1709 for (int count1 = 0; count1 < nb_samples / 2; count1++) {
1710 int byte[2];
1711
1712 byte[0] = bytestream2_get_byteu(&gb);
1713 if (st) byte[1] = bytestream2_get_byteu(&gb);
1714 for (int i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
1715 for (int channel = 0; channel < channels; channel++) {
1716 int sample = sign_extend(byte[channel] >> i, 4) * (1 << shift[channel]);
1717 sample = (sample +
1718 c->status[channel].sample1 * coeff[channel][0] +
1719 c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
1720 c->status[channel].sample2 = c->status[channel].sample1;
1721 c->status[channel].sample1 = av_clip_int16(sample);
1722 *samples++ = c->status[channel].sample1;
1723 }
1724 }
1725 }
1726 bytestream2_seek(&gb, 0, SEEK_END);
1727 ) /* End of CASE */
1728 #if CONFIG_ADPCM_EA_R1_DECODER || CONFIG_ADPCM_EA_R2_DECODER || CONFIG_ADPCM_EA_R3_DECODER
1729 400 case AV_CODEC_ID_ADPCM_EA_R1:
1730 case AV_CODEC_ID_ADPCM_EA_R2:
1731 case AV_CODEC_ID_ADPCM_EA_R3: {
1732 /* channel numbering
1733 2chan: 0=fl, 1=fr
1734 4chan: 0=fl, 1=rl, 2=fr, 3=rr
1735 6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */
1736 400 const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1737 int previous_sample, current_sample, next_sample;
1738 int coeff1, coeff2;
1739 int shift;
1740 uint16_t *samplesC;
1741 400 int count = 0;
1742 int offsets[6];
1743
1744
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 400 times.
1200 for (unsigned channel = 0; channel < channels; channel++)
1745
2/2
✓ Branch 0 taken 250 times.
✓ Branch 1 taken 550 times.
800 offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
1746 550 bytestream2_get_le32(&gb)) +
1747 800 (channels + 1) * 4;
1748
1749
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 400 times.
1200 for (unsigned channel = 0; channel < channels; channel++) {
1750 int count1;
1751
1752 800 bytestream2_seek(&gb, offsets[channel], SEEK_SET);
1753 800 samplesC = samples_p[channel];
1754
1755
2/2
✓ Branch 0 taken 190 times.
✓ Branch 1 taken 610 times.
800 if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1756 190 current_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1757 190 previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1758 } else {
1759 610 current_sample = c->status[channel].predictor;
1760 610 previous_sample = c->status[channel].prev_sample;
1761 }
1762
1763
2/2
✓ Branch 0 taken 41192 times.
✓ Branch 1 taken 800 times.
41992 for (count1 = 0; count1 < nb_samples / 28; count1++) {
1764 41192 int byte = bytestream2_get_byte(&gb);
1765
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 41180 times.
41192 if (byte == 0xEE) { /* only seen in R2 and R3 */
1766 12 current_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1767 12 previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1768
1769
2/2
✓ Branch 0 taken 336 times.
✓ Branch 1 taken 12 times.
348 for (int count2 = 0; count2 < 28; count2++)
1770 336 *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
1771 } else {
1772 41180 coeff1 = ea_adpcm_table[ byte >> 4 ];
1773 41180 coeff2 = ea_adpcm_table[(byte >> 4) + 4];
1774 41180 shift = 20 - (byte & 0x0F);
1775
1776
2/2
✓ Branch 0 taken 1153040 times.
✓ Branch 1 taken 41180 times.
1194220 for (int count2 = 0; count2 < 28; count2++) {
1777
2/2
✓ Branch 0 taken 576520 times.
✓ Branch 1 taken 576520 times.
1153040 if (count2 & 1)
1778 576520 next_sample = (unsigned)sign_extend(byte, 4) << shift;
1779 else {
1780 576520 byte = bytestream2_get_byte(&gb);
1781 576520 next_sample = (unsigned)sign_extend(byte >> 4, 4) << shift;
1782 }
1783
1784 1153040 next_sample += (current_sample * coeff1) +
1785 1153040 (previous_sample * coeff2);
1786 1153040 next_sample = av_clip_int16(next_sample >> 8);
1787
1788 1153040 previous_sample = current_sample;
1789 1153040 current_sample = next_sample;
1790 1153040 *samplesC++ = current_sample;
1791 }
1792 }
1793 }
1794
2/2
✓ Branch 0 taken 400 times.
✓ Branch 1 taken 400 times.
800 if (!count) {
1795 400 count = count1;
1796
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 400 times.
400 } else if (count != count1) {
1797 av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
1798 count = FFMAX(count, count1);
1799 }
1800
1801
2/2
✓ Branch 0 taken 610 times.
✓ Branch 1 taken 190 times.
800 if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1802 610 c->status[channel].predictor = current_sample;
1803 610 c->status[channel].prev_sample = previous_sample;
1804 }
1805 }
1806
1807 400 frame->nb_samples = count * 28;
1808 400 bytestream2_seek(&gb, 0, SEEK_END);
1809 400 break;
1810 }
1811 #endif /* CONFIG_ADPCM_EA_Rx_DECODER */
1812
10/10
✓ Branch 1 taken 4800 times.
✓ Branch 2 taken 2400 times.
✓ Branch 4 taken 2400 times.
✓ Branch 5 taken 600 times.
✓ Branch 7 taken 36000 times.
✓ Branch 8 taken 9000 times.
✓ Branch 9 taken 9000 times.
✓ Branch 10 taken 600 times.
✓ Branch 11 taken 600 times.
✓ Branch 12 taken 600 times.
53400 CASE(ADPCM_EA_XAS,
1813 for (int channel=0; channel < channels; channel++) {
1814 int coeff[2][4], shift[4];
1815 int16_t *s = samples_p[channel];
1816 for (int n = 0; n < 4; n++, s += 32) {
1817 int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1818 for (int i = 0; i < 2; i++)
1819 coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];
1820 s[0] = val & ~0x0F;
1821
1822 val = sign_extend(bytestream2_get_le16u(&gb), 16);
1823 shift[n] = 20 - (val & 0x0F);
1824 s[1] = val & ~0x0F;
1825 }
1826
1827 for (int m = 2; m < 32; m += 2) {
1828 s = &samples_p[channel][m];
1829 for (int n = 0; n < 4; n++, s += 32) {
1830 int level, pred;
1831 int byte = bytestream2_get_byteu(&gb);
1832
1833 level = sign_extend(byte >> 4, 4) * (1 << shift[n]);
1834 pred = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
1835 s[0] = av_clip_int16((level + pred + 0x80) >> 8);
1836
1837 level = sign_extend(byte, 4) * (1 << shift[n]);
1838 pred = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
1839 s[1] = av_clip_int16((level + pred + 0x80) >> 8);
1840 }
1841 }
1842 }
1843 ) /* End of CASE */
1844 CASE(ADPCM_IMA_ACORN,
1845 for (int channel = 0; channel < channels; channel++) {
1846 ADPCMChannelStatus *cs = &c->status[channel];
1847 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1848 cs->step_index = bytestream2_get_le16u(&gb) & 0xFF;
1849 if (cs->step_index > 88u){
1850 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1851 channel, cs->step_index);
1852 return AVERROR_INVALIDDATA;
1853 }
1854 }
1855 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1856 int byte = bytestream2_get_byteu(&gb);
1857 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte & 0x0F, 3);
1858 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte >> 4, 3);
1859 }
1860 ) /* End of CASE */
1861
7/10
✗ Branch 0 not taken.
✓ Branch 1 taken 161 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 161 times.
✓ Branch 13 taken 110929 times.
✓ Branch 14 taken 161 times.
✓ Branch 15 taken 22 times.
✓ Branch 16 taken 139 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 22 times.
111090 CASE(ADPCM_IMA_AMV,
1862 av_assert0(channels == 1);
1863
1864 /*
1865 * Header format:
1866 * int16_t predictor;
1867 * uint8_t step_index;
1868 * uint8_t reserved;
1869 * uint32_t frame_size;
1870 *
1871 * Some implementations have step_index as 16-bits, but others
1872 * only use the lower 8 and store garbage in the upper 8.
1873 */
1874 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1875 c->status[0].step_index = bytestream2_get_byteu(&gb);
1876 bytestream2_skipu(&gb, 5);
1877 if (c->status[0].step_index > 88u) {
1878 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1879 c->status[0].step_index);
1880 return AVERROR_INVALIDDATA;
1881 }
1882
1883 for (int n = nb_samples >> 1; n > 0; n--) {
1884 int v = bytestream2_get_byteu(&gb);
1885
1886 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
1887 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v & 0xf, 3);
1888 }
1889
1890 if (nb_samples & 1) {
1891 int v = bytestream2_get_byteu(&gb);
1892 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
1893
1894 if (v & 0x0F) {
1895 /* Holds true on all the http://samples.mplayerhq.hu/amv samples. */
1896 av_log(avctx, AV_LOG_WARNING, "Last nibble set on packet with odd sample count.\n");
1897 av_log(avctx, AV_LOG_WARNING, "Sample will be skipped.\n");
1898 }
1899 }
1900 ) /* End of CASE */
1901
5/6
✗ Branch 3 not taken.
✓ Branch 4 taken 350 times.
✓ Branch 6 taken 350 times.
✓ Branch 7 taken 350 times.
✓ Branch 11 taken 89600 times.
✓ Branch 12 taken 350 times.
90300 CASE(ADPCM_IMA_SMJPEG,
1902 for (int i = 0; i < channels; i++) {
1903 c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
1904 c->status[i].step_index = bytestream2_get_byteu(&gb);
1905 bytestream2_skipu(&gb, 1);
1906 if (c->status[i].step_index > 88u) {
1907 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1908 c->status[i].step_index);
1909 return AVERROR_INVALIDDATA;
1910 }
1911 }
1912
1913 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1914 int v = bytestream2_get_byteu(&gb);
1915
1916 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4 );
1917 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf);
1918 }
1919 ) /* End of CASE */
1920
2/2
✓ Branch 3 taken 262096 times.
✓ Branch 4 taken 64 times.
262160 CASE(ADPCM_CT,
1921 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1922 int v = bytestream2_get_byteu(&gb);
1923 *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
1924 *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1925 }
1926 ) /* End of CASE */
1927 #if CONFIG_ADPCM_SBPRO_2_DECODER || CONFIG_ADPCM_SBPRO_3_DECODER || \
1928 CONFIG_ADPCM_SBPRO_4_DECODER
1929 57 case AV_CODEC_ID_ADPCM_SBPRO_4:
1930 case AV_CODEC_ID_ADPCM_SBPRO_3:
1931 case AV_CODEC_ID_ADPCM_SBPRO_2:
1932
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 54 times.
57 if (!c->status[0].step_index) {
1933 /* the first byte is a raw sample */
1934 3 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1935
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (st)
1936 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1937 3 c->status[0].step_index = 1;
1938 3 nb_samples--;
1939 }
1940
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 31 times.
57 if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1941
2/2
✓ Branch 0 taken 52230 times.
✓ Branch 1 taken 26 times.
52256 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1942 52230 int byte = bytestream2_get_byteu(&gb);
1943 104460 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1944 52230 byte >> 4, 4, 0);
1945 52230 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1946 52230 byte & 0x0F, 4, 0);
1947 }
1948
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 13 times.
31 } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1949
2/2
✓ Branch 0 taken 34820 times.
✓ Branch 1 taken 18 times.
34838 for (int n = (nb_samples<<st) / 3; n > 0; n--) {
1950 34820 int byte = bytestream2_get_byteu(&gb);
1951 69640 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1952 34820 byte >> 5 , 3, 0);
1953 69640 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1954 34820 (byte >> 2) & 0x07, 3, 0);
1955 34820 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1956 34820 byte & 0x03, 2, 0);
1957 }
1958 } else {
1959
2/2
✓ Branch 0 taken 26115 times.
✓ Branch 1 taken 13 times.
26128 for (int n = nb_samples >> (2 - st); n > 0; n--) {
1960 26115 int byte = bytestream2_get_byteu(&gb);
1961 52230 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1962 26115 byte >> 6 , 2, 2);
1963 52230 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1964 26115 (byte >> 4) & 0x03, 2, 2);
1965 52230 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1966 26115 (byte >> 2) & 0x03, 2, 2);
1967 26115 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1968 26115 byte & 0x03, 2, 2);
1969 }
1970 }
1971 57 break;
1972 #endif /* CONFIG_ADPCM_SBPRO_x_DECODER */
1973 195 CASE(ADPCM_SWF,
1974 adpcm_swf_decode(avctx, buf, buf_size, samples);
1975 bytestream2_seek(&gb, 0, SEEK_END);
1976 ) /* End of CASE */
1977
2/2
✓ Branch 3 taken 552960 times.
✓ Branch 4 taken 136 times.
553096 CASE(ADPCM_YAMAHA,
1978 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1979