FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/adpcm.c
Date: 2022-12-09 07:38:14
Exec Total Coverage
Lines: 554 724 76.5%
Functions: 16 21 76.2%
Branches: 447 668 66.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_EA_R1:
328 case AV_CODEC_ID_ADPCM_EA_R2:
329 case AV_CODEC_ID_ADPCM_EA_R3:
330 case AV_CODEC_ID_ADPCM_EA_XAS:
331 case AV_CODEC_ID_ADPCM_THP:
332 case AV_CODEC_ID_ADPCM_THP_LE:
333 case AV_CODEC_ID_ADPCM_AFC:
334 case AV_CODEC_ID_ADPCM_DTK:
335 case AV_CODEC_ID_ADPCM_PSX:
336 case AV_CODEC_ID_ADPCM_MTAF:
337 case AV_CODEC_ID_ADPCM_ARGO:
338 case AV_CODEC_ID_ADPCM_IMA_MOFLEX:
339 87 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
340 87 break;
341 8 case AV_CODEC_ID_ADPCM_IMA_WS:
342
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 6 times.
8 avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :
343 AV_SAMPLE_FMT_S16;
344 8 break;
345 11 case AV_CODEC_ID_ADPCM_MS:
346
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 :
347 AV_SAMPLE_FMT_S16;
348 11 break;
349 81 default:
350 81 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
351 }
352 187 return 0;
353 }
354
355 static inline int16_t adpcm_agm_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
356 {
357 int delta, pred, step, add;
358
359 pred = c->predictor;
360 delta = nibble & 7;
361 step = c->step;
362 add = (delta * 2 + 1) * step;
363 if (add < 0)
364 add = add + 7;
365
366 if ((nibble & 8) == 0)
367 pred = av_clip(pred + (add >> 3), -32767, 32767);
368 else
369 pred = av_clip(pred - (add >> 3), -32767, 32767);
370
371 switch (delta) {
372 case 7:
373 step *= 0x99;
374 break;
375 case 6:
376 c->step = av_clip(c->step * 2, 127, 24576);
377 c->predictor = pred;
378 return pred;
379 case 5:
380 step *= 0x66;
381 break;
382 case 4:
383 step *= 0x4d;
384 break;
385 default:
386 step *= 0x39;
387 break;
388 }
389
390 if (step < 0)
391 step += 0x3f;
392
393 c->step = step >> 6;
394 c->step = av_clip(c->step, 127, 24576);
395 c->predictor = pred;
396 return pred;
397 }
398
399 10314918 static inline int16_t adpcm_ima_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
400 {
401 int step_index;
402 int predictor;
403 int sign, delta, diff, step;
404
405 10314918 step = ff_adpcm_step_table[c->step_index];
406 10314918 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
407 10314918 step_index = av_clip(step_index, 0, 88);
408
409 10314918 sign = nibble & 8;
410 10314918 delta = nibble & 7;
411 /* perform direct multiplication instead of series of jumps proposed by
412 * the reference ADPCM implementation since modern CPUs can do the mults
413 * quickly enough */
414 10314918 diff = ((2 * delta + 1) * step) >> shift;
415 10314918 predictor = c->predictor;
416
2/2
✓ Branch 0 taken 5109700 times.
✓ Branch 1 taken 5205218 times.
10314918 if (sign) predictor -= diff;
417 5205218 else predictor += diff;
418
419 10314918 c->predictor = av_clip_int16(predictor);
420 10314918 c->step_index = step_index;
421
422 10314918 return (int16_t)c->predictor;
423 }
424
425 679344 static inline int16_t adpcm_ima_alp_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int shift)
426 {
427 int step_index;
428 int predictor;
429 int sign, delta, diff, step;
430
431 679344 step = ff_adpcm_step_table[c->step_index];
432 679344 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
433 679344 step_index = av_clip(step_index, 0, 88);
434
435 679344 sign = nibble & 8;
436 679344 delta = nibble & 7;
437 679344 diff = (delta * step) >> shift;
438 679344 predictor = c->predictor;
439
2/2
✓ Branch 0 taken 339842 times.
✓ Branch 1 taken 339502 times.
679344 if (sign) predictor -= diff;
440 339502 else predictor += diff;
441
442 679344 c->predictor = av_clip_int16(predictor);
443 679344 c->step_index = step_index;
444
445 679344 return (int16_t)c->predictor;
446 }
447
448 static inline int16_t adpcm_ima_mtf_expand_nibble(ADPCMChannelStatus *c, int nibble)
449 {
450 int step_index, step, delta, predictor;
451
452 step = ff_adpcm_step_table[c->step_index];
453
454 delta = step * (2 * nibble - 15);
455 predictor = c->predictor + delta;
456
457 step_index = c->step_index + mtf_index_table[(unsigned)nibble];
458 c->predictor = av_clip_int16(predictor >> 4);
459 c->step_index = av_clip(step_index, 0, 88);
460
461 return (int16_t)c->predictor;
462 }
463
464 386028 static inline int16_t adpcm_ima_cunning_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
465 {
466 int step_index;
467 int predictor;
468 int step;
469
470 386028 nibble = sign_extend(nibble & 0xF, 4);
471
472 386028 step = ima_cunning_step_table[c->step_index];
473 386028 step_index = c->step_index + ima_cunning_index_table[abs(nibble)];
474 386028 step_index = av_clip(step_index, 0, 60);
475
476 386028 predictor = c->predictor + step * nibble;
477
478 386028 c->predictor = av_clip_int16(predictor);
479 386028 c->step_index = step_index;
480
481 386028 return c->predictor;
482 }
483
484 static inline int16_t adpcm_ima_wav_expand_nibble(ADPCMChannelStatus *c, GetBitContext *gb, int bps)
485 {
486 int nibble, step_index, predictor, sign, delta, diff, step, shift;
487
488 shift = bps - 1;
489 nibble = get_bits_le(gb, bps),
490 step = ff_adpcm_step_table[c->step_index];
491 step_index = c->step_index + adpcm_index_tables[bps - 2][nibble];
492 step_index = av_clip(step_index, 0, 88);
493
494 sign = nibble & (1 << shift);
495 delta = av_mod_uintp2(nibble, shift);
496 diff = ((2 * delta + 1) * step) >> shift;
497 predictor = c->predictor;
498 if (sign) predictor -= diff;
499 else predictor += diff;
500
501 c->predictor = av_clip_int16(predictor);
502 c->step_index = step_index;
503
504 return (int16_t)c->predictor;
505 }
506
507 4696090 static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble)
508 {
509 int step_index;
510 int predictor;
511 int diff, step;
512
513 4696090 step = ff_adpcm_step_table[c->step_index];
514 4696090 step_index = c->step_index + ff_adpcm_index_table[nibble];
515 4696090 step_index = av_clip(step_index, 0, 88);
516
517 4696090 diff = step >> 3;
518
2/2
✓ Branch 0 taken 1076119 times.
✓ Branch 1 taken 3619971 times.
4696090 if (nibble & 4) diff += step;
519
2/2
✓ Branch 0 taken 1984447 times.
✓ Branch 1 taken 2711643 times.
4696090 if (nibble & 2) diff += step >> 1;
520
2/2
✓ Branch 0 taken 2159261 times.
✓ Branch 1 taken 2536829 times.
4696090 if (nibble & 1) diff += step >> 2;
521
522
2/2
✓ Branch 0 taken 2338238 times.
✓ Branch 1 taken 2357852 times.
4696090 if (nibble & 8)
523 2338238 predictor = c->predictor - diff;
524 else
525 2357852 predictor = c->predictor + diff;
526
527 4696090 c->predictor = av_clip_int16(predictor);
528 4696090 c->step_index = step_index;
529
530 4696090 return c->predictor;
531 }
532
533 2229948 static inline int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
534 {
535 int predictor;
536
537 2229948 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
538
2/2
✓ Branch 0 taken 972056 times.
✓ Branch 1 taken 1257892 times.
2229948 predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
539
540 2229948 c->sample2 = c->sample1;
541 2229948 c->sample1 = av_clip_int16(predictor);
542 2229948 c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
543
2/2
✓ Branch 0 taken 92703 times.
✓ Branch 1 taken 2137245 times.
2229948 if (c->idelta < 16) c->idelta = 16;
544
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2229948 times.
2229948 if (c->idelta > INT_MAX/768) {
545 av_log(NULL, AV_LOG_WARNING, "idelta overflow\n");
546 c->idelta = INT_MAX/768;
547 }
548
549 2229948 return c->sample1;
550 }
551
552 55124 static inline int16_t adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)
553 {
554 int step_index, predictor, sign, delta, diff, step;
555
556 55124 step = oki_step_table[c->step_index];
557 55124 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
558 55124 step_index = av_clip(step_index, 0, 48);
559
560 55124 sign = nibble & 8;
561 55124 delta = nibble & 7;
562 55124 diff = ((2 * delta + 1) * step) >> 3;
563 55124 predictor = c->predictor;
564
2/2
✓ Branch 0 taken 25352 times.
✓ Branch 1 taken 29772 times.
55124 if (sign) predictor -= diff;
565 29772 else predictor += diff;
566
567 55124 c->predictor = av_clip_intp2(predictor, 11);
568 55124 c->step_index = step_index;
569
570 55124 return c->predictor * 16;
571 }
572
573 524192 static inline int16_t adpcm_ct_expand_nibble(ADPCMChannelStatus *c, int8_t nibble)
574 {
575 int sign, delta, diff;
576 int new_step;
577
578 524192 sign = nibble & 8;
579 524192 delta = nibble & 7;
580 /* perform direct multiplication instead of series of jumps proposed by
581 * the reference ADPCM implementation since modern CPUs can do the mults
582 * quickly enough */
583 524192 diff = ((2 * delta + 1) * c->step) >> 3;
584 /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */
585
2/2
✓ Branch 0 taken 263253 times.
✓ Branch 1 taken 260939 times.
524192 c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);
586 524192 c->predictor = av_clip_int16(c->predictor);
587 /* calculate new step and clamp it to range 511..32767 */
588 524192 new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;
589 524192 c->step = av_clip(new_step, 511, 32767);
590
591 524192 return (int16_t)c->predictor;
592 }
593
594 313380 static inline int16_t adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, int8_t nibble, int size, int shift)
595 {
596 int sign, delta, diff;
597
598 313380 sign = nibble & (1<<(size-1));
599 313380 delta = nibble & ((1<<(size-1))-1);
600 313380 diff = delta << (7 + c->step + shift);
601
602 /* clamp result */
603
2/2
✓ Branch 0 taken 129904 times.
✓ Branch 1 taken 183476 times.
313380 c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);
604
605 /* calculate new step */
606
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)
607 75080 c->step++;
608
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)
609 75080 c->step--;
610
611 313380 return (int16_t) c->predictor;
612 }
613
614 1105920 static inline int16_t adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
615 {
616
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 1105915 times.
1105920 if(!c->step) {
617 5 c->predictor = 0;
618 5 c->step = 127;
619 }
620
621 1105920 c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
622 1105920 c->predictor = av_clip_int16(c->predictor);
623 1105920 c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
624 1105920 c->step = av_clip(c->step, 127, 24576);
625 1105920 return c->predictor;
626 }
627
628 static inline int16_t adpcm_mtaf_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
629 {
630 c->predictor += mtaf_stepsize[c->step][nibble];
631 c->predictor = av_clip_int16(c->predictor);
632 c->step += ff_adpcm_index_table[nibble];
633 c->step = av_clip_uintp2(c->step, 5);
634 return c->predictor;
635 }
636
637 static inline int16_t adpcm_zork_expand_nibble(ADPCMChannelStatus *c, uint8_t nibble)
638 {
639 int16_t index = c->step_index;
640 uint32_t lookup_sample = ff_adpcm_step_table[index];
641 int32_t sample = 0;
642
643 if (nibble & 0x40)
644 sample += lookup_sample;
645 if (nibble & 0x20)
646 sample += lookup_sample >> 1;
647 if (nibble & 0x10)
648 sample += lookup_sample >> 2;
649 if (nibble & 0x08)
650 sample += lookup_sample >> 3;
651 if (nibble & 0x04)
652 sample += lookup_sample >> 4;
653 if (nibble & 0x02)
654 sample += lookup_sample >> 5;
655 if (nibble & 0x01)
656 sample += lookup_sample >> 6;
657 if (nibble & 0x80)
658 sample = -sample;
659
660 sample += c->predictor;
661 sample = av_clip_int16(sample);
662
663 index += zork_index_table[(nibble >> 4) & 7];
664 index = av_clip(index, 0, 88);
665
666 c->predictor = sample;
667 c->step_index = index;
668
669 return sample;
670 }
671
672 666 static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,
673 const uint8_t *in, ADPCMChannelStatus *left,
674 ADPCMChannelStatus *right, int channels, int sample_offset)
675 {
676 int i, j;
677 int shift,filter,f0,f1;
678 int s_1,s_2;
679 int d,s,t;
680
681 666 out0 += sample_offset;
682
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 666 times.
666 if (channels == 1)
683 out1 = out0 + 28;
684 else
685 666 out1 += sample_offset;
686
687
2/2
✓ Branch 0 taken 2664 times.
✓ Branch 1 taken 666 times.
3330 for(i=0;i<4;i++) {
688 2664 shift = 12 - (in[4+i*2] & 15);
689 2664 filter = in[4+i*2] >> 4;
690
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2664 times.
2664 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {
691 avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
692 filter=0;
693 }
694
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2664 times.
2664 if (shift < 0) {
695 avpriv_request_sample(avctx, "unknown XA-ADPCM shift %d", shift);
696 shift = 0;
697 }
698 2664 f0 = xa_adpcm_table[filter][0];
699 2664 f1 = xa_adpcm_table[filter][1];
700
701 2664 s_1 = left->sample1;
702 2664 s_2 = left->sample2;
703
704
2/2
✓ Branch 0 taken 74592 times.
✓ Branch 1 taken 2664 times.
77256 for(j=0;j<28;j++) {
705 74592 d = in[16+i+j*4];
706
707 74592 t = sign_extend(d, 4);
708 74592 s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
709 74592 s_2 = s_1;
710 74592 s_1 = av_clip_int16(s);
711 74592 out0[j] = s_1;
712 }
713
714
1/2
✓ Branch 0 taken 2664 times.
✗ Branch 1 not taken.
2664 if (channels == 2) {
715 2664 left->sample1 = s_1;
716 2664 left->sample2 = s_2;
717 2664 s_1 = right->sample1;
718 2664 s_2 = right->sample2;
719 }
720
721 2664 shift = 12 - (in[5+i*2] & 15);
722 2664 filter = in[5+i*2] >> 4;
723
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) {
724 avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);
725 filter=0;
726 }
727
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2664 times.
2664 if (shift < 0) {
728 avpriv_request_sample(avctx, "unknown XA-ADPCM shift %d", shift);
729 shift = 0;
730 }
731
732 2664 f0 = xa_adpcm_table[filter][0];
733 2664 f1 = xa_adpcm_table[filter][1];
734
735
2/2
✓ Branch 0 taken 74592 times.
✓ Branch 1 taken 2664 times.
77256 for(j=0;j<28;j++) {
736 74592 d = in[16+i+j*4];
737
738 74592 t = sign_extend(d >> 4, 4);
739 74592 s = t*(1<<shift) + ((s_1*f0 + s_2*f1+32)>>6);
740 74592 s_2 = s_1;
741 74592 s_1 = av_clip_int16(s);
742 74592 out1[j] = s_1;
743 }
744
745
1/2
✓ Branch 0 taken 2664 times.
✗ Branch 1 not taken.
2664 if (channels == 2) {
746 2664 right->sample1 = s_1;
747 2664 right->sample2 = s_2;
748 } else {
749 left->sample1 = s_1;
750 left->sample2 = s_2;
751 }
752
753 2664 out0 += 28 * (3 - channels);
754 2664 out1 += 28 * (3 - channels);
755 }
756
757 666 return 0;
758 }
759
760 195 static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)
761 {
762 195 ADPCMDecodeContext *c = avctx->priv_data;
763 GetBitContext gb;
764 const int8_t *table;
765 195 int channels = avctx->ch_layout.nb_channels;
766 int k0, signmask, nb_bits, count;
767 195 int size = buf_size*8;
768 int i;
769
770 195 init_get_bits(&gb, buf, size);
771
772 //read bits & initial values
773 195 nb_bits = get_bits(&gb, 2)+2;
774 195 table = swf_index_tables[nb_bits-2];
775 195 k0 = 1 << (nb_bits-2);
776 195 signmask = 1 << (nb_bits-1);
777
778
2/2
✓ Branch 1 taken 195 times.
✓ Branch 2 taken 195 times.
390 while (get_bits_count(&gb) <= size - 22 * channels) {
779
2/2
✓ Branch 0 taken 390 times.
✓ Branch 1 taken 195 times.
585 for (i = 0; i < channels; i++) {
780 390 *samples++ = c->status[i].predictor = get_sbits(&gb, 16);
781 390 c->status[i].step_index = get_bits(&gb, 6);
782 }
783
784
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++) {
785 int i;
786
787
2/2
✓ Branch 0 taken 1597050 times.
✓ Branch 1 taken 798525 times.
2395575 for (i = 0; i < channels; i++) {
788 // similar to IMA adpcm
789 1597050 int delta = get_bits(&gb, nb_bits);
790 1597050 int step = ff_adpcm_step_table[c->status[i].step_index];
791 1597050 int vpdiff = 0; // vpdiff = (delta+0.5)*step/4
792 1597050 int k = k0;
793
794 do {
795
2/2
✓ Branch 0 taken 1979561 times.
✓ Branch 1 taken 2811589 times.
4791150 if (delta & k)
796 1979561 vpdiff += step;
797 4791150 step >>= 1;
798 4791150 k >>= 1;
799
2/2
✓ Branch 0 taken 3194100 times.
✓ Branch 1 taken 1597050 times.
4791150 } while(k);
800 1597050 vpdiff += step;
801
802
2/2
✓ Branch 0 taken 803527 times.
✓ Branch 1 taken 793523 times.
1597050 if (delta & signmask)
803 803527 c->status[i].predictor -= vpdiff;
804 else
805 793523 c->status[i].predictor += vpdiff;
806
807 1597050 c->status[i].step_index += table[delta & (~signmask)];
808
809 1597050 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
810 1597050 c->status[i].predictor = av_clip_int16(c->status[i].predictor);
811
812 1597050 *samples++ = c->status[i].predictor;
813 }
814 }
815 }
816 195 }
817
818 18335520 int16_t ff_adpcm_argo_expand_nibble(ADPCMChannelStatus *cs, int nibble, int shift, int flag)
819 {
820 18335520 int sample = sign_extend(nibble, 4) * (1 << shift);
821
822
2/2
✓ Branch 0 taken 9806208 times.
✓ Branch 1 taken 8529312 times.
18335520 if (flag)
823 9806208 sample += (8 * cs->sample1) - (4 * cs->sample2);
824 else
825 8529312 sample += 4 * cs->sample1;
826
827 18335520 sample = av_clip_int16(sample >> 2);
828
829 18335520 cs->sample2 = cs->sample1;
830 18335520 cs->sample1 = sample;
831
832 18335520 return sample;
833 }
834
835 /**
836 * Get the number of samples (per channel) that will be decoded from the packet.
837 * In one case, this is actually the maximum number of samples possible to
838 * decode with the given buf_size.
839 *
840 * @param[out] coded_samples set to the number of samples as coded in the
841 * packet, or 0 if the codec does not encode the
842 * number of samples in each frame.
843 * @param[out] approx_nb_samples set to non-zero if the number of samples
844 * returned is an approximation.
845 */
846 37569 static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
847 int buf_size, int *coded_samples, int *approx_nb_samples)
848 {
849 37569 ADPCMDecodeContext *s = avctx->priv_data;
850 37569 int nb_samples = 0;
851 37569 int ch = avctx->ch_layout.nb_channels;
852 37569 int has_coded_samples = 0;
853 int header_size;
854
855 37569 *coded_samples = 0;
856 37569 *approx_nb_samples = 0;
857
858
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37569 times.
37569 if(ch <= 0)
859 return 0;
860
861
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) {
862 /* constant, only check buf_size */
863 600 case AV_CODEC_ID_ADPCM_EA_XAS:
864
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 600 times.
600 if (buf_size < 76 * ch)
865 return 0;
866 600 nb_samples = 128;
867 600 break;
868 26342 case AV_CODEC_ID_ADPCM_IMA_QT:
869
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26342 times.
26342 if (buf_size < 34 * ch)
870 return 0;
871 26342 nb_samples = 64;
872 26342 break;
873 /* simple 4-bit adpcm */
874 1084 case AV_CODEC_ID_ADPCM_CT:
875 case AV_CODEC_ID_ADPCM_IMA_APC:
876 case AV_CODEC_ID_ADPCM_IMA_CUNNING:
877 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
878 case AV_CODEC_ID_ADPCM_IMA_OKI:
879 case AV_CODEC_ID_ADPCM_IMA_WS:
880 case AV_CODEC_ID_ADPCM_YAMAHA:
881 case AV_CODEC_ID_ADPCM_AICA:
882 case AV_CODEC_ID_ADPCM_IMA_SSI:
883 case AV_CODEC_ID_ADPCM_IMA_APM:
884 case AV_CODEC_ID_ADPCM_IMA_ALP:
885 case AV_CODEC_ID_ADPCM_IMA_MTF:
886 1084 nb_samples = buf_size * 2 / ch;
887 1084 break;
888 }
889
2/2
✓ Branch 0 taken 28026 times.
✓ Branch 1 taken 9543 times.
37569 if (nb_samples)
890 28026 return nb_samples;
891
892 /* simple 4-bit adpcm, with header */
893 9543 header_size = 0;
894
3/3
✓ Branch 0 taken 145 times.
✓ Branch 1 taken 350 times.
✓ Branch 2 taken 9048 times.
9543 switch (avctx->codec->id) {
895 145 case AV_CODEC_ID_ADPCM_4XM:
896 case AV_CODEC_ID_ADPCM_AGM:
897 case AV_CODEC_ID_ADPCM_IMA_ACORN:
898 case AV_CODEC_ID_ADPCM_IMA_DAT4:
899 case AV_CODEC_ID_ADPCM_IMA_MOFLEX:
900 145 case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;
901 350 case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4 * ch; break;
902 }
903
2/2
✓ Branch 0 taken 495 times.
✓ Branch 1 taken 9048 times.
9543 if (header_size > 0)
904 495 return (buf_size - header_size) * 2 / ch;
905
906 /* more complex formats */
907
17/20
✓ 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 taken 32 times.
✓ Branch 17 taken 946 times.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
9048 switch (avctx->codec->id) {
908 161 case AV_CODEC_ID_ADPCM_IMA_AMV:
909 161 bytestream2_skip(gb, 4);
910 161 has_coded_samples = 1;
911 161 *coded_samples = bytestream2_get_le32u(gb);
912 161 nb_samples = FFMIN((buf_size - 8) * 2, *coded_samples);
913 161 bytestream2_seek(gb, -8, SEEK_CUR);
914 161 break;
915 158 case AV_CODEC_ID_ADPCM_EA:
916 158 has_coded_samples = 1;
917 158 *coded_samples = bytestream2_get_le32(gb);
918 158 *coded_samples -= *coded_samples % 28;
919 158 nb_samples = (buf_size - 12) / 30 * 28;
920 158 break;
921 47 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
922 47 has_coded_samples = 1;
923 47 *coded_samples = bytestream2_get_le32(gb);
924 47 nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
925 47 break;
926 30 case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
927 30 nb_samples = (buf_size - ch) / ch * 2;
928 30 break;
929 400 case AV_CODEC_ID_ADPCM_EA_R1:
930 case AV_CODEC_ID_ADPCM_EA_R2:
931 case AV_CODEC_ID_ADPCM_EA_R3:
932 /* maximum number of samples */
933 /* has internal offsets and a per-frame switch to signal raw 16-bit */
934 400 has_coded_samples = 1;
935
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) {
936 95 case AV_CODEC_ID_ADPCM_EA_R1:
937 95 header_size = 4 + 9 * ch;
938 95 *coded_samples = bytestream2_get_le32(gb);
939 95 break;
940 180 case AV_CODEC_ID_ADPCM_EA_R2:
941 180 header_size = 4 + 5 * ch;
942 180 *coded_samples = bytestream2_get_le32(gb);
943 180 break;
944 125 case AV_CODEC_ID_ADPCM_EA_R3:
945 125 header_size = 4 + 5 * ch;
946 125 *coded_samples = bytestream2_get_be32(gb);
947 125 break;
948 }
949 400 *coded_samples -= *coded_samples % 28;
950 400 nb_samples = (buf_size - header_size) * 2 / ch;
951 400 nb_samples -= nb_samples % 28;
952 400 *approx_nb_samples = 1;
953 400 break;
954 642 case AV_CODEC_ID_ADPCM_IMA_DK3:
955
1/2
✓ Branch 0 taken 642 times.
✗ Branch 1 not taken.
642 if (avctx->block_align > 0)
956 642 buf_size = FFMIN(buf_size, avctx->block_align);
957 642 nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
958 642 break;
959 649 case AV_CODEC_ID_ADPCM_IMA_DK4:
960
1/2
✓ Branch 0 taken 649 times.
✗ Branch 1 not taken.
649 if (avctx->block_align > 0)
961 649 buf_size = FFMIN(buf_size, avctx->block_align);
962
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 649 times.
649 if (buf_size < 4 * ch)
963 return AVERROR_INVALIDDATA;
964 649 nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
965 649 break;
966 1000 case AV_CODEC_ID_ADPCM_IMA_RAD:
967
1/2
✓ Branch 0 taken 1000 times.
✗ Branch 1 not taken.
1000 if (avctx->block_align > 0)
968 1000 buf_size = FFMIN(buf_size, avctx->block_align);
969 1000 nb_samples = (buf_size - 4 * ch) * 2 / ch;
970 1000 break;
971
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,
972 int bsize = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
973 int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
974 if (avctx->block_align > 0)
975 buf_size = FFMIN(buf_size, avctx->block_align);
976 if (buf_size < 4 * ch)
977 return AVERROR_INVALIDDATA;
978 nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;
979 ) /* End of CASE */
980 2943 case AV_CODEC_ID_ADPCM_MS:
981
1/2
✓ Branch 0 taken 2943 times.
✗ Branch 1 not taken.
2943 if (avctx->block_align > 0)
982 2943 buf_size = FFMIN(buf_size, avctx->block_align);
983 2943 nb_samples = (buf_size - 6 * ch) * 2 / ch;
984 2943 break;
985 case AV_CODEC_ID_ADPCM_MTAF:
986 if (avctx->block_align > 0)
987 buf_size = FFMIN(buf_size, avctx->block_align);
988 nb_samples = (buf_size - 16 * (ch / 2)) * 2 / ch;
989 break;
990 57 case AV_CODEC_ID_ADPCM_SBPRO_2:
991 case AV_CODEC_ID_ADPCM_SBPRO_3:
992 case AV_CODEC_ID_ADPCM_SBPRO_4:
993 {
994 int samples_per_byte;
995
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) {
996 13 case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
997 18 case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
998 26 case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
999 }
1000
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 54 times.
57 if (!s->status[0].step_index) {
1001
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (buf_size < ch)
1002 return AVERROR_INVALIDDATA;
1003 3 nb_samples++;
1004 3 buf_size -= ch;
1005 }
1006 57 nb_samples += buf_size * samples_per_byte / ch;
1007 57 break;
1008 }
1009 195 case AV_CODEC_ID_ADPCM_SWF:
1010 {
1011 195 int buf_bits = buf_size * 8 - 2;
1012 195 int nbits = (bytestream2_get_byte(gb) >> 6) + 2;
1013 195 int block_hdr_size = 22 * ch;
1014 195 int block_size = block_hdr_size + nbits * ch * 4095;
1015 195 int nblocks = buf_bits / block_size;
1016 195 int bits_left = buf_bits - nblocks * block_size;
1017 195 nb_samples = nblocks * 4096;
1018
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 195 times.
195 if (bits_left >= block_hdr_size)
1019 nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
1020 195 break;
1021 }
1022 71 case AV_CODEC_ID_ADPCM_THP:
1023 case AV_CODEC_ID_ADPCM_THP_LE:
1024
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
71 if (avctx->extradata) {
1025 nb_samples = buf_size * 14 / (8 * ch);
1026 break;
1027 }
1028 71 has_coded_samples = 1;
1029 71 bytestream2_skip(gb, 4); // channel size
1030 142 *coded_samples = (avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE) ?
1031
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
142 bytestream2_get_le32(gb) :
1032 71 bytestream2_get_be32(gb);
1033 71 buf_size -= 8 + 36 * ch;
1034 71 buf_size /= ch;
1035 71 nb_samples = buf_size / 8 * 14;
1036
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
71 if (buf_size % 8 > 1)
1037 nb_samples += (buf_size % 8 - 1) * 2;
1038 71 *approx_nb_samples = 1;
1039 71 break;
1040 12 case AV_CODEC_ID_ADPCM_AFC:
1041 12 nb_samples = buf_size / (9 * ch) * 16;
1042 12 break;
1043 37 case AV_CODEC_ID_ADPCM_XA:
1044 37 nb_samples = (buf_size / 128) * 224 / ch;
1045 37 break;
1046 32 case AV_CODEC_ID_ADPCM_DTK:
1047 case AV_CODEC_ID_ADPCM_PSX:
1048 32 nb_samples = buf_size / (16 * ch) * 28;
1049 32 break;
1050 946 case AV_CODEC_ID_ADPCM_ARGO:
1051 946 nb_samples = buf_size / avctx->block_align * 32;
1052 946 break;
1053 case AV_CODEC_ID_ADPCM_ZORK:
1054 nb_samples = buf_size / ch;
1055 break;
1056 }
1057
1058 /* validate coded sample count */
1059
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))
1060 return AVERROR_INVALIDDATA;
1061
1062 9048 return nb_samples;
1063 }
1064
1065 37569 static int adpcm_decode_frame(AVCodecContext *avctx, AVFrame *frame,
1066 int *got_frame_ptr, AVPacket *avpkt)
1067 {
1068 37569 const uint8_t *buf = avpkt->data;
1069 37569 int buf_size = avpkt->size;
1070 37569 ADPCMDecodeContext *c = avctx->priv_data;
1071 37569 int channels = avctx->ch_layout.nb_channels;
1072 int16_t *samples;
1073 int16_t **samples_p;
1074 int st; /* stereo */
1075 int nb_samples, coded_samples, approx_nb_samples, ret;
1076 GetByteContext gb;
1077
1078 37569 bytestream2_init(&gb, buf, buf_size);
1079 37569 nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);
1080
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37569 times.
37569 if (nb_samples <= 0) {
1081 av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
1082 return AVERROR_INVALIDDATA;
1083 }
1084
1085 /* get output buffer */
1086 37569 frame->nb_samples = nb_samples;
1087
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 37569 times.
37569 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1088 return ret;
1089 37569 samples = (int16_t *)frame->data[0];
1090 37569 samples_p = (int16_t **)frame->extended_data;
1091
1092 /* use coded_samples when applicable */
1093 /* it is always <= nb_samples, so the output buffer will be large enough */
1094
2/2
✓ Branch 0 taken 837 times.
✓ Branch 1 taken 36732 times.
37569 if (coded_samples) {
1095
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)
1096 av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
1097 837 frame->nb_samples = nb_samples = coded_samples;
1098 }
1099
1100 37569 st = channels == 2 ? 1 : 0;
1101
1102
32/42
✓ 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 taken 37 times.
✓ Branch 20 taken 47 times.
✓ Branch 21 taken 49 times.
✓ Branch 22 taken 158 times.
✓ Branch 23 taken 30 times.
✓ Branch 24 taken 400 times.
✓ Branch 25 taken 600 times.
✗ Branch 26 not taken.
✓ Branch 27 taken 161 times.
✓ Branch 28 taken 350 times.
✓ Branch 29 taken 64 times.
✓ Branch 30 taken 57 times.
✓ Branch 31 taken 195 times.
✓ Branch 32 taken 136 times.
✗ Branch 33 not taken.
✓ Branch 34 taken 12 times.
✓ Branch 35 taken 71 times.
✓ Branch 36 taken 32 times.
✗ Branch 37 not taken.
✓ Branch 38 taken 946 times.
✗ Branch 39 not taken.
✗ Branch 40 not taken.
✗ Branch 41 not taken.
37569 switch(avctx->codec->id) {
1103
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,
1104 /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
1105 Channel data is interleaved per-chunk. */
1106 for (int channel = 0; channel < channels; channel++) {
1107 ADPCMChannelStatus *cs = &c->status[channel];
1108 int predictor;
1109 int step_index;
1110 /* (pppppp) (piiiiiii) */
1111
1112 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
1113 predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
1114 step_index = predictor & 0x7F;
1115 predictor &= ~0x7F;
1116
1117 if (cs->step_index == step_index) {
1118 int diff = predictor - cs->predictor;
1119 if (diff < 0)
1120 diff = - diff;
1121 if (diff > 0x7f)
1122 goto update;
1123 } else {
1124 update:
1125 cs->step_index = step_index;
1126 cs->predictor = predictor;
1127 }
1128
1129 if (cs->step_index > 88u){
1130 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1131 channel, cs->step_index);
1132 return AVERROR_INVALIDDATA;
1133 }
1134
1135 samples = samples_p[channel];
1136
1137 for (int m = 0; m < 64; m += 2) {
1138 int byte = bytestream2_get_byteu(&gb);
1139 samples[m ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F);
1140 samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4 );
1141 }
1142 }
1143 ) /* End of CASE */
1144
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,
1145 for (int i = 0; i < channels; i++) {
1146 ADPCMChannelStatus *cs = &c->status[i];
1147 cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
1148
1149 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1150 if (cs->step_index > 88u){
1151 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1152 i, cs->step_index);
1153 return AVERROR_INVALIDDATA;
1154 }
1155 }
1156
1157 if (avctx->bits_per_coded_sample != 4) {
1158 int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
1159 int block_size = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
1160 uint8_t temp[20 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
1161 GetBitContext g;
1162
1163 for (int n = 0; n < (nb_samples - 1) / samples_per_block; n++) {
1164 for (int i = 0; i < channels; i++) {
1165 ADPCMChannelStatus *cs = &c->status[i];
1166 samples = &samples_p[i][1 + n * samples_per_block];
1167 for (int j = 0; j < block_size; j++) {
1168 temp[j] = buf[4 * channels + block_size * n * channels +
1169 (j % 4) + (j / 4) * (channels * 4) + i * 4];
1170 }
1171 ret = init_get_bits8(&g, (const uint8_t *)&temp, block_size);
1172 if (ret < 0)
1173 return ret;
1174 for (int m = 0; m < samples_per_block; m++) {
1175 samples[m] = adpcm_ima_wav_expand_nibble(cs, &g,
1176 avctx->bits_per_coded_sample);
1177 }
1178 }
1179 }
1180 bytestream2_skip(&gb, avctx->block_align - channels * 4);
1181 } else {
1182 for (int n = 0; n < (nb_samples - 1) / 8; n++) {
1183 for (int i = 0; i < channels; i++) {
1184 ADPCMChannelStatus *cs = &c->status[i];
1185 samples = &samples_p[i][1 + n * 8];
1186 for (int m = 0; m < 8; m += 2) {
1187 int v = bytestream2_get_byteu(&gb);
1188 samples[m ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1189 samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
1190 }
1191 }
1192 }
1193 }
1194 ) /* End of CASE */
1195
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,
1196 for (int i = 0; i < channels; i++)
1197 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1198
1199 for (int i = 0; i < channels; i++) {
1200 c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1201 if (c->status[i].step_index > 88u) {
1202 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1203 i, c->status[i].step_index);
1204 return AVERROR_INVALIDDATA;
1205 }
1206 }
1207
1208 for (int i = 0; i < channels; i++) {
1209 ADPCMChannelStatus *cs = &c->status[i];
1210 samples = (int16_t *)frame->data[i];
1211 for (int n = nb_samples >> 1; n > 0; n--) {
1212 int v = bytestream2_get_byteu(&gb);
1213 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
1214 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 4);
1215 }
1216 }
1217 ) /* End of CASE */
1218 CASE(ADPCM_AGM,
1219 for (int i = 0; i < channels; i++)
1220 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1221 for (int i = 0; i < channels; i++)
1222 c->status[i].step = sign_extend(bytestream2_get_le16u(&gb), 16);
1223
1224 for (int n = 0; n < nb_samples >> (1 - st); n++) {
1225 int v = bytestream2_get_byteu(&gb);
1226 *samples++ = adpcm_agm_expand_nibble(&c->status[0], v & 0xF);
1227 *samples++ = adpcm_agm_expand_nibble(&c->status[st], v >> 4 );
1228 }
1229 ) /* End of CASE */
1230
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,
1231 int block_predictor;
1232
1233 if (avctx->ch_layout.nb_channels > 2) {
1234 for (int channel = 0; channel < avctx->ch_layout.nb_channels; channel++) {
1235 samples = samples_p[channel];
1236 block_predictor = bytestream2_get_byteu(&gb);
1237 if (block_predictor > 6) {
1238 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[%d] = %d\n",
1239 channel, block_predictor);
1240 return AVERROR_INVALIDDATA;
1241 }
1242 c->status[channel].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1243 c->status[channel].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1244 c->status[channel].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1245 c->status[channel].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1246 c->status[channel].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1247 *samples++ = c->status[channel].sample2;
1248 *samples++ = c->status[channel].sample1;
1249 for (int n = (nb_samples - 2) >> 1; n > 0; n--) {
1250 int byte = bytestream2_get_byteu(&gb);
1251 *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte >> 4 );
1252 *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte & 0x0F);
1253 }
1254 }
1255 } else {
1256 block_predictor = bytestream2_get_byteu(&gb);
1257 if (block_predictor > 6) {
1258 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
1259 block_predictor);
1260 return AVERROR_INVALIDDATA;
1261 }
1262 c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1263 c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1264 if (st) {
1265 block_predictor = bytestream2_get_byteu(&gb);
1266 if (block_predictor > 6) {
1267 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
1268 block_predictor);
1269 return AVERROR_INVALIDDATA;
1270 }
1271 c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1272 c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1273 }
1274 c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1275 if (st){
1276 c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1277 }
1278
1279 c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1280 if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1281 c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1282 if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1283
1284 *samples++ = c->status[0].sample2;
1285 if (st) *samples++ = c->status[1].sample2;
1286 *samples++ = c->status[0].sample1;
1287 if (st) *samples++ = c->status[1].sample1;
1288 for (int n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
1289 int byte = bytestream2_get_byteu(&gb);
1290 *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4 );
1291 *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
1292 }
1293 }
1294 ) /* End of CASE */
1295 CASE(ADPCM_MTAF,
1296 for (int channel = 0; channel < channels; channel += 2) {
1297 bytestream2_skipu(&gb, 4);
1298 c->status[channel ].step = bytestream2_get_le16u(&gb) & 0x1f;
1299 c->status[channel + 1].step = bytestream2_get_le16u(&gb) & 0x1f;
1300 c->status[channel ].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1301 bytestream2_skipu(&gb, 2);
1302 c->status[channel + 1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1303 bytestream2_skipu(&gb, 2);
1304 for (int n = 0; n < nb_samples; n += 2) {
1305 int v = bytestream2_get_byteu(&gb);
1306 samples_p[channel][n ] = adpcm_mtaf_expand_nibble(&c->status[channel], v & 0x0F);
1307 samples_p[channel][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel], v >> 4 );
1308 }
1309 for (int n = 0; n < nb_samples; n += 2) {
1310 int v = bytestream2_get_byteu(&gb);
1311 samples_p[channel + 1][n ] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v & 0x0F);
1312 samples_p[channel + 1][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v >> 4 );
1313 }
1314 }
1315 ) /* End of CASE */
1316
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,
1317 for (int channel = 0; channel < channels; channel++) {
1318 ADPCMChannelStatus *cs = &c->status[channel];
1319 cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
1320 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1321 if (cs->step_index > 88u){
1322 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1323 channel, cs->step_index);
1324 return AVERROR_INVALIDDATA;
1325 }
1326 }
1327 for (int n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
1328 int v = bytestream2_get_byteu(&gb);
1329 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3);
1330 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1331 }
1332 ) /* End of CASE */
1333
1334 /* DK3 ADPCM support macro */
1335 #define DK3_GET_NEXT_NIBBLE() \
1336 if (decode_top_nibble_next) { \
1337 nibble = last_byte >> 4; \
1338 decode_top_nibble_next = 0; \
1339 } else { \
1340 last_byte = bytestream2_get_byteu(&gb); \
1341 nibble = last_byte & 0x0F; \
1342 decode_top_nibble_next = 1; \
1343 }
1344
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,
1345 int last_byte = 0;
1346 int nibble;
1347 int decode_top_nibble_next = 0;
1348 int diff_channel;
1349 const int16_t *samples_end = samples + channels * nb_samples;
1350
1351 bytestream2_skipu(&gb, 10);
1352 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1353 c->status[1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1354 c->status[0].step_index = bytestream2_get_byteu(&gb);
1355 c->status[1].step_index = bytestream2_get_byteu(&gb);
1356 if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
1357 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
1358 c->status[0].step_index, c->status[1].step_index);
1359 return AVERROR_INVALIDDATA;
1360 }
1361 /* sign extend the predictors */
1362 diff_channel = c->status[1].predictor;
1363
1364 while (samples < samples_end) {
1365
1366 /* for this algorithm, c->status[0] is the sum channel and
1367 * c->status[1] is the diff channel */
1368
1369 /* process the first predictor of the sum channel */
1370 DK3_GET_NEXT_NIBBLE();
1371 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1372
1373 /* process the diff channel predictor */
1374 DK3_GET_NEXT_NIBBLE();
1375 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
1376
1377 /* process the first pair of stereo PCM samples */
1378 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1379 *samples++ = c->status[0].predictor + c->status[1].predictor;
1380 *samples++ = c->status[0].predictor - c->status[1].predictor;
1381
1382 /* process the second predictor of the sum channel */
1383 DK3_GET_NEXT_NIBBLE();
1384 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1385
1386 /* process the second pair of stereo PCM samples */
1387 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1388 *samples++ = c->status[0].predictor + c->status[1].predictor;
1389 *samples++ = c->status[0].predictor - c->status[1].predictor;
1390 }
1391
1392 if ((bytestream2_tell(&gb) & 1))
1393 bytestream2_skip(&gb, 1);
1394 ) /* End of CASE */
1395
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,
1396 for (int channel = 0; channel < channels; channel++) {
1397 ADPCMChannelStatus *cs = &c->status[channel];
1398 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1399 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1400 if (cs->step_index > 88u){
1401 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1402 channel, cs->step_index);
1403 return AVERROR_INVALIDDATA;
1404 }
1405 }
1406
1407 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1408 int v1, v2;
1409 int v = bytestream2_get_byteu(&gb);
1410 /* nibbles are swapped for mono */
1411 if (st) {
1412 v1 = v >> 4;
1413 v2 = v & 0x0F;
1414 } else {
1415 v2 = v >> 4;
1416 v1 = v & 0x0F;
1417 }
1418 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
1419 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
1420 }
1421 ) /* End of CASE */
1422 CASE(ADPCM_IMA_MOFLEX,
1423 for (int channel = 0; channel < channels; channel++) {
1424 ADPCMChannelStatus *cs = &c->status[channel];
1425 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1426 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1427 if (cs->step_index > 88u){
1428 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1429 channel, cs->step_index);
1430 return AVERROR_INVALIDDATA;
1431 }
1432 }
1433
1434 for (int subframe = 0; subframe < nb_samples / 256; subframe++) {
1435 for (int channel = 0; channel < channels; channel++) {
1436 samples = samples_p[channel] + 256 * subframe;
1437 for (int n = 0; n < 256; n += 2) {
1438 int v = bytestream2_get_byteu(&gb);
1439 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1440 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1441 }
1442 }
1443 }
1444 ) /* End of CASE */
1445 CASE(ADPCM_IMA_DAT4,
1446 for (int channel = 0; channel < channels; channel++) {
1447 ADPCMChannelStatus *cs = &c->status[channel];
1448 samples = samples_p[channel];
1449 bytestream2_skip(&gb, 4);
1450 for (int n = 0; n < nb_samples; n += 2) {
1451 int v = bytestream2_get_byteu(&gb);
1452 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
1453 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1454 }
1455 }
1456 ) /* End of CASE */
1457
2/2
✓ Branch 3 taken 732060 times.
✓ Branch 4 taken 179 times.
732239 CASE(ADPCM_IMA_APC,
1458 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1459 int v = bytestream2_get_byteu(&gb);
1460 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
1461 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1462 }
1463 ) /* End of CASE */
1464
2/2
✓ Branch 3 taken 514600 times.
✓ Branch 4 taken 127 times.
514727 CASE(ADPCM_IMA_SSI,
1465 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1466 int v = bytestream2_get_byteu(&gb);
1467 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0], v >> 4 );
1468 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0x0F);
1469 }
1470 ) /* End of CASE */
1471
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,
1472 for (int n = nb_samples / 2; n > 0; n--) {
1473 for (int channel = 0; channel < channels; channel++) {
1474 int v = bytestream2_get_byteu(&gb);
1475 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[channel], v >> 4 );
1476 samples[st] = adpcm_ima_qt_expand_nibble(&c->status[channel], v & 0x0F);
1477 }
1478 samples += channels;
1479 }
1480 ) /* End of CASE */
1481
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,
1482 for (int n = nb_samples / 2; n > 0; n--) {
1483 for (int channel = 0; channel < channels; channel++) {
1484 int v = bytestream2_get_byteu(&gb);
1485 *samples++ = adpcm_ima_alp_expand_nibble(&c->status[channel], v >> 4 , 2);
1486 samples[st] = adpcm_ima_alp_expand_nibble(&c->status[channel], v & 0x0F, 2);
1487 }
1488 samples += channels;
1489 }
1490 ) /* End of CASE */
1491
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,
1492 for (int channel = 0; channel < channels; channel++) {
1493 int16_t *smp = samples_p[channel];
1494 for (int n = 0; n < nb_samples / 2; n++) {
1495 int v = bytestream2_get_byteu(&gb);
1496 *smp++ = adpcm_ima_cunning_expand_nibble(&c->status[channel], v & 0x0F);
1497 *smp++ = adpcm_ima_cunning_expand_nibble(&c->status[channel], v >> 4);
1498 }
1499 }
1500 ) /* End of CASE */
1501
2/2
✓ Branch 3 taken 27562 times.
✓ Branch 4 taken 7 times.
27569 CASE(ADPCM_IMA_OKI,
1502 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1503 int v = bytestream2_get_byteu(&gb);
1504 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[0], v >> 4 );
1505 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[st], v & 0x0F);
1506 }
1507 ) /* End of CASE */
1508
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,
1509 for (int channel = 0; channel < channels; channel++) {
1510 ADPCMChannelStatus *cs = &c->status[channel];
1511 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1512 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1513 if (cs->step_index > 88u){
1514 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1515 channel, cs->step_index);
1516 return AVERROR_INVALIDDATA;
1517 }
1518 }
1519 for (int n = 0; n < nb_samples / 2; n++) {
1520 int byte[2];
1521
1522 byte[0] = bytestream2_get_byteu(&gb);
1523 if (st)
1524 byte[1] = bytestream2_get_byteu(&gb);
1525 for (int channel = 0; channel < channels; channel++) {
1526 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] & 0x0F, 3);
1527 }
1528 for (int channel = 0; channel < channels; channel++) {
1529 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] >> 4 , 3);
1530 }
1531 }
1532 ) /* End of CASE */
1533
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,
1534 if (c->vqa_version == 3) {
1535 for (int channel = 0; channel < channels; channel++) {
1536 int16_t *smp = samples_p[channel];
1537
1538 for (int n = nb_samples / 2; n > 0; n--) {
1539 int v = bytestream2_get_byteu(&gb);
1540 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1541 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1542 }
1543 }
1544 } else {
1545 for (int n = nb_samples / 2; n > 0; n--) {
1546 for (int channel = 0; channel < channels; channel++) {
1547 int v = bytestream2_get_byteu(&gb);
1548 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1549 samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1550 }
1551 samples += channels;
1552 }
1553 }
1554 bytestream2_seek(&gb, 0, SEEK_END);
1555 ) /* End of CASE */
1556
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,
1557 int16_t *out0 = samples_p[0];
1558 int16_t *out1 = samples_p[1];
1559 int samples_per_block = 28 * (3 - channels) * 4;
1560 int sample_offset = 0;
1561 int bytes_remaining;
1562 while (bytestream2_get_bytes_left(&gb) >= 128) {
1563 if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
1564 &c->status[0], &c->status[1],
1565 channels, sample_offset)) < 0)
1566 return ret;
1567 bytestream2_skipu(&gb, 128);
1568 sample_offset += samples_per_block;
1569 }
1570 /* Less than a full block of data left, e.g. when reading from
1571 * 2324 byte per sector XA; the remainder is padding */
1572 bytes_remaining = bytestream2_get_bytes_left(&gb);
1573 if (bytes_remaining > 0) {
1574 bytestream2_skip(&gb, bytes_remaining);
1575 }
1576 ) /* End of CASE */
1577
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,
1578 for (int i = 0; i <= st; i++) {
1579 c->status[i].step_index = bytestream2_get_le32u(&gb);
1580 if (c->status[i].step_index > 88u) {
1581 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1582 i, c->status[i].step_index);
1583 return AVERROR_INVALIDDATA;
1584 }
1585 }
1586 for (int i = 0; i <= st; i++) {
1587 c->status[i].predictor = bytestream2_get_le32u(&gb);
1588 if (FFABS((int64_t)c->status[i].predictor) > (1<<16))
1589 return AVERROR_INVALIDDATA;
1590 }
1591
1592 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1593 int byte = bytestream2_get_byteu(&gb);
1594 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 3);
1595 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
1596 }
1597 ) /* End of CASE */
1598
2/2
✓ Branch 3 taken 71392 times.
✓ Branch 4 taken 49 times.
71441 CASE(ADPCM_IMA_EA_SEAD,
1599 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1600 int byte = bytestream2_get_byteu(&gb);
1601 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);
1602 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
1603 }
1604 ) /* End of CASE */
1605
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,
1606 int previous_left_sample, previous_right_sample;
1607 int current_left_sample, current_right_sample;
1608 int next_left_sample, next_right_sample;
1609 int coeff1l, coeff2l, coeff1r, coeff2r;
1610 int shift_left, shift_right;
1611
1612 /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
1613 each coding 28 stereo samples. */
1614
1615 if (channels != 2)
1616 return AVERROR_INVALIDDATA;
1617
1618 current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1619 previous_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1620 current_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1621 previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1622
1623 for (int count1 = 0; count1 < nb_samples / 28; count1++) {
1624 int byte = bytestream2_get_byteu(&gb);
1625 coeff1l = ea_adpcm_table[ byte >> 4 ];
1626 coeff2l = ea_adpcm_table[(byte >> 4 ) + 4];
1627 coeff1r = ea_adpcm_table[ byte & 0x0F];
1628 coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];
1629
1630 byte = bytestream2_get_byteu(&gb);
1631 shift_left = 20 - (byte >> 4);
1632 shift_right = 20 - (byte & 0x0F);
1633
1634 for (int count2 = 0; count2 < 28; count2++) {
1635 byte = bytestream2_get_byteu(&gb);
1636 next_left_sample = sign_extend(byte >> 4, 4) * (1 << shift_left);
1637 next_right_sample = sign_extend(byte, 4) * (1 << shift_right);
1638
1639 next_left_sample = (next_left_sample +
1640 (current_left_sample * coeff1l) +
1641 (previous_left_sample * coeff2l) + 0x80) >> 8;
1642 next_right_sample = (next_right_sample +
1643 (current_right_sample * coeff1r) +
1644 (previous_right_sample * coeff2r) + 0x80) >> 8;
1645
1646 previous_left_sample = current_left_sample;
1647 current_left_sample = av_clip_int16(next_left_sample);
1648 previous_right_sample = current_right_sample;
1649 current_right_sample = av_clip_int16(next_right_sample);
1650 *samples++ = current_left_sample;
1651 *samples++ = current_right_sample;
1652 }
1653 }
1654
1655 bytestream2_skip(&gb, 2); // Skip terminating 0x0000
1656 ) /* End of CASE */
1657
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,
1658 int coeff[2][2], shift[2];
1659
1660 for (int channel = 0; channel < channels; channel++) {
1661 int byte = bytestream2_get_byteu(&gb);
1662 for (int i = 0; i < 2; i++)
1663 coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
1664 shift[channel] = 20 - (byte & 0x0F);
1665 }
1666 for (int count1 = 0; count1 < nb_samples / 2; count1++) {
1667 int byte[2];
1668
1669 byte[0] = bytestream2_get_byteu(&gb);
1670 if (st) byte[1] = bytestream2_get_byteu(&gb);
1671 for (int i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
1672 for (int channel = 0; channel < channels; channel++) {
1673 int sample = sign_extend(byte[channel] >> i, 4) * (1 << shift[channel]);
1674 sample = (sample +
1675 c->status[channel].sample1 * coeff[channel][0] +
1676 c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
1677 c->status[channel].sample2 = c->status[channel].sample1;
1678 c->status[channel].sample1 = av_clip_int16(sample);
1679 *samples++ = c->status[channel].sample1;
1680 }
1681 }
1682 }
1683 bytestream2_seek(&gb, 0, SEEK_END);
1684 ) /* End of CASE */
1685 #if CONFIG_ADPCM_EA_R1_DECODER || CONFIG_ADPCM_EA_R2_DECODER || CONFIG_ADPCM_EA_R3_DECODER
1686 400 case AV_CODEC_ID_ADPCM_EA_R1:
1687 case AV_CODEC_ID_ADPCM_EA_R2:
1688 case AV_CODEC_ID_ADPCM_EA_R3: {
1689 /* channel numbering
1690 2chan: 0=fl, 1=fr
1691 4chan: 0=fl, 1=rl, 2=fr, 3=rr
1692 6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */
1693 400 const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1694 int previous_sample, current_sample, next_sample;
1695 int coeff1, coeff2;
1696 int shift;
1697 uint16_t *samplesC;
1698 400 int count = 0;
1699 int offsets[6];
1700
1701
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 400 times.
1200 for (unsigned channel = 0; channel < channels; channel++)
1702
2/2
✓ Branch 0 taken 250 times.
✓ Branch 1 taken 550 times.
800 offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
1703 550 bytestream2_get_le32(&gb)) +
1704 800 (channels + 1) * 4;
1705
1706
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 400 times.
1200 for (unsigned channel = 0; channel < channels; channel++) {
1707 int count1;
1708
1709 800 bytestream2_seek(&gb, offsets[channel], SEEK_SET);
1710 800 samplesC = samples_p[channel];
1711
1712
2/2
✓ Branch 0 taken 190 times.
✓ Branch 1 taken 610 times.
800 if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1713 190 current_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1714 190 previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1715 } else {
1716 610 current_sample = c->status[channel].predictor;
1717 610 previous_sample = c->status[channel].prev_sample;
1718 }
1719
1720
2/2
✓ Branch 0 taken 41192 times.
✓ Branch 1 taken 800 times.
41992 for (count1 = 0; count1 < nb_samples / 28; count1++) {
1721 41192 int byte = bytestream2_get_byte(&gb);
1722
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 41180 times.
41192 if (byte == 0xEE) { /* only seen in R2 and R3 */
1723 12 current_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1724 12 previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1725
1726
2/2
✓ Branch 0 taken 336 times.
✓ Branch 1 taken 12 times.
348 for (int count2 = 0; count2 < 28; count2++)
1727 336 *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
1728 } else {
1729 41180 coeff1 = ea_adpcm_table[ byte >> 4 ];
1730 41180 coeff2 = ea_adpcm_table[(byte >> 4) + 4];
1731 41180 shift = 20 - (byte & 0x0F);
1732
1733
2/2
✓ Branch 0 taken 1153040 times.
✓ Branch 1 taken 41180 times.
1194220 for (int count2 = 0; count2 < 28; count2++) {
1734
2/2
✓ Branch 0 taken 576520 times.
✓ Branch 1 taken 576520 times.
1153040 if (count2 & 1)
1735 576520 next_sample = (unsigned)sign_extend(byte, 4) << shift;
1736 else {
1737 576520 byte = bytestream2_get_byte(&gb);
1738 576520 next_sample = (unsigned)sign_extend(byte >> 4, 4) << shift;
1739 }
1740
1741 1153040 next_sample += (current_sample * coeff1) +
1742 1153040 (previous_sample * coeff2);
1743 1153040 next_sample = av_clip_int16(next_sample >> 8);
1744
1745 1153040 previous_sample = current_sample;
1746 1153040 current_sample = next_sample;
1747 1153040 *samplesC++ = current_sample;
1748 }
1749 }
1750 }
1751
2/2
✓ Branch 0 taken 400 times.
✓ Branch 1 taken 400 times.
800 if (!count) {
1752 400 count = count1;
1753
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 400 times.
400 } else if (count != count1) {
1754 av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
1755 count = FFMAX(count, count1);
1756 }
1757
1758
2/2
✓ Branch 0 taken 610 times.
✓ Branch 1 taken 190 times.
800 if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1759 610 c->status[channel].predictor = current_sample;
1760 610 c->status[channel].prev_sample = previous_sample;
1761 }
1762 }
1763
1764 400 frame->nb_samples = count * 28;
1765 400 bytestream2_seek(&gb, 0, SEEK_END);
1766 400 break;
1767 }
1768 #endif /* CONFIG_ADPCM_EA_Rx_DECODER */
1769
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,
1770 for (int channel=0; channel < channels; channel++) {
1771 int coeff[2][4], shift[4];
1772 int16_t *s = samples_p[channel];
1773 for (int n = 0; n < 4; n++, s += 32) {
1774 int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1775 for (int i = 0; i < 2; i++)
1776 coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];
1777 s[0] = val & ~0x0F;
1778
1779 val = sign_extend(bytestream2_get_le16u(&gb), 16);
1780 shift[n] = 20 - (val & 0x0F);
1781 s[1] = val & ~0x0F;
1782 }
1783
1784 for (int m = 2; m < 32; m += 2) {
1785 s = &samples_p[channel][m];
1786 for (int n = 0; n < 4; n++, s += 32) {
1787 int level, pred;
1788 int byte = bytestream2_get_byteu(&gb);
1789
1790 level = sign_extend(byte >> 4, 4) * (1 << shift[n]);
1791 pred = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
1792 s[0] = av_clip_int16((level + pred + 0x80) >> 8);
1793
1794 level = sign_extend(byte, 4) * (1 << shift[n]);
1795 pred = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
1796 s[1] = av_clip_int16((level + pred + 0x80) >> 8);
1797 }
1798 }
1799 }
1800 ) /* End of CASE */
1801 CASE(ADPCM_IMA_ACORN,
1802 for (int channel = 0; channel < channels; channel++) {
1803 ADPCMChannelStatus *cs = &c->status[channel];
1804 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1805 cs->step_index = bytestream2_get_le16u(&gb) & 0xFF;
1806 if (cs->step_index > 88u){
1807 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1808 channel, cs->step_index);
1809 return AVERROR_INVALIDDATA;
1810 }
1811 }
1812 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1813 int byte = bytestream2_get_byteu(&gb);
1814 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte & 0x0F, 3);
1815 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte >> 4, 3);
1816 }
1817 ) /* End of CASE */
1818
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,
1819 av_assert0(channels == 1);
1820
1821 /*
1822 * Header format:
1823 * int16_t predictor;
1824 * uint8_t step_index;
1825 * uint8_t reserved;
1826 * uint32_t frame_size;
1827 *
1828 * Some implementations have step_index as 16-bits, but others
1829 * only use the lower 8 and store garbage in the upper 8.
1830 */
1831 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1832 c->status[0].step_index = bytestream2_get_byteu(&gb);
1833 bytestream2_skipu(&gb, 5);
1834 if (c->status[0].step_index > 88u) {
1835 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1836 c->status[0].step_index);
1837 return AVERROR_INVALIDDATA;
1838 }
1839
1840 for (int n = nb_samples >> 1; n > 0; n--) {
1841 int v = bytestream2_get_byteu(&gb);
1842
1843 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
1844 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v & 0xf, 3);
1845 }
1846
1847 if (nb_samples & 1) {
1848 int v = bytestream2_get_byteu(&gb);
1849 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
1850
1851 if (v & 0x0F) {
1852 /* Holds true on all the http://samples.mplayerhq.hu/amv samples. */
1853 av_log(avctx, AV_LOG_WARNING, "Last nibble set on packet with odd sample count.\n");
1854 av_log(avctx, AV_LOG_WARNING, "Sample will be skipped.\n");
1855 }
1856 }
1857 ) /* End of CASE */
1858
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,
1859 for (int i = 0; i < channels; i++) {
1860 c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
1861 c->status[i].step_index = bytestream2_get_byteu(&gb);
1862 bytestream2_skipu(&gb, 1);
1863 if (c->status[i].step_index > 88u) {
1864 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1865 c->status[i].step_index);
1866 return AVERROR_INVALIDDATA;
1867 }
1868 }
1869
1870 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1871 int v = bytestream2_get_byteu(&gb);
1872
1873 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4 );
1874 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf);
1875 }
1876 ) /* End of CASE */
1877
2/2
✓ Branch 3 taken 262096 times.
✓ Branch 4 taken 64 times.
262160 CASE(ADPCM_CT,
1878 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1879 int v = bytestream2_get_byteu(&gb);
1880 *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
1881 *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1882 }
1883 ) /* End of CASE */
1884 #if CONFIG_ADPCM_SBPRO_2_DECODER || CONFIG_ADPCM_SBPRO_3_DECODER || \
1885 CONFIG_ADPCM_SBPRO_4_DECODER
1886 57 case AV_CODEC_ID_ADPCM_SBPRO_4:
1887 case AV_CODEC_ID_ADPCM_SBPRO_3:
1888 case AV_CODEC_ID_ADPCM_SBPRO_2:
1889
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 54 times.
57 if (!c->status[0].step_index) {
1890 /* the first byte is a raw sample */
1891 3 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1892
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (st)
1893 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1894 3 c->status[0].step_index = 1;
1895 3 nb_samples--;
1896 }
1897
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 31 times.
57 if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1898
2/2
✓ Branch 0 taken 52230 times.
✓ Branch 1 taken 26 times.
52256 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1899 52230 int byte = bytestream2_get_byteu(&gb);
1900 104460 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1901 52230 byte >> 4, 4, 0);
1902 52230 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1903 52230 byte & 0x0F, 4, 0);
1904 }
1905
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 13 times.
31 } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1906
2/2
✓ Branch 0 taken 34820 times.
✓ Branch 1 taken 18 times.
34838 for (int n = (nb_samples<<st) / 3; n > 0; n--) {
1907 34820 int byte = bytestream2_get_byteu(&gb);
1908 69640 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1909 34820 byte >> 5 , 3, 0);
1910 69640 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1911 34820 (byte >> 2) & 0x07, 3,