FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/adpcm.c
Date: 2024-11-20 23:03:26
Exec Total Coverage
Lines: 554 728 76.1%
Functions: 16 21 76.2%
Branches: 452 690 65.5%
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 23 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 8 times.
✓ Branch 6 taken 151 times.
 187 switch(avctx->codec->id) {
260 3 case AV_CODEC_ID_ADPCM_IMA_AMV:
261 3 max_channels = 1;
262 3 break;
263 23 case AV_CODEC_ID_ADPCM_AFC:
264 case AV_CODEC_ID_ADPCM_EA_R1:
265 case AV_CODEC_ID_ADPCM_EA_R2:
266 case AV_CODEC_ID_ADPCM_EA_R3:
267 case AV_CODEC_ID_ADPCM_EA_XAS:
268 case AV_CODEC_ID_ADPCM_MS:
269 23 max_channels = 6;
270 23 break;
271 ✗ case AV_CODEC_ID_ADPCM_MTAF:
272 ✗ min_channels = 2;
273 ✗ max_channels = 8;
274 ✗ if (avctx->ch_layout.nb_channels & 1) {
275 ✗ avpriv_request_sample(avctx, "channel count %d", avctx->ch_layout.nb_channels);
276 ✗ return AVERROR_PATCHWELCOME;
277 }
278 ✗ break;
279 2 case AV_CODEC_ID_ADPCM_DTK:
280 2 min_channels = 2;
281 2 break;
282 ✗ case AV_CODEC_ID_ADPCM_PSX:
283 ✗ max_channels = 8;
284 ✗ if (avctx->ch_layout.nb_channels <= 0 ||
285 ✗ avctx->block_align % (16 * avctx->ch_layout.nb_channels))
286 ✗ return AVERROR_INVALIDDATA;
287 ✗ break;
288 8 case AV_CODEC_ID_ADPCM_IMA_DAT4:
289 case AV_CODEC_ID_ADPCM_THP:
290 case AV_CODEC_ID_ADPCM_THP_LE:
291 8 max_channels = 14;
292 8 break;
293 }
294
1/2
✓ Branch 0 taken 187 times.
✗ Branch 1 not taken.
 187 if (avctx->ch_layout.nb_channels < min_channels ||
295
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 187 times.
 187 avctx->ch_layout.nb_channels > max_channels) {
296 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
297 ✗ return AVERROR(EINVAL);
298 }
299
300
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) {
301 10 case AV_CODEC_ID_ADPCM_IMA_WAV:
302
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)
303 ✗ return AVERROR_INVALIDDATA;
304 10 break;
305 6 case AV_CODEC_ID_ADPCM_ARGO:
306
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (avctx->bits_per_coded_sample != 4 ||
307
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 avctx->block_align != 17 * avctx->ch_layout.nb_channels)
308 ✗ return AVERROR_INVALIDDATA;
309 6 break;
310 ✗ case AV_CODEC_ID_ADPCM_ZORK:
311 ✗ if (avctx->bits_per_coded_sample != 8)
312 ✗ return AVERROR_INVALIDDATA;
313 ✗ break;
314 171 default:
315 171 break;
316 }
317
318
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) {
319 87 case AV_CODEC_ID_ADPCM_AICA:
320 case AV_CODEC_ID_ADPCM_IMA_CUNNING:
321 case AV_CODEC_ID_ADPCM_IMA_DAT4:
322 case AV_CODEC_ID_ADPCM_IMA_QT:
323 case AV_CODEC_ID_ADPCM_IMA_WAV:
324 case AV_CODEC_ID_ADPCM_4XM:
325 case AV_CODEC_ID_ADPCM_XA:
326 case AV_CODEC_ID_ADPCM_XMD:
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 10327321 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 10327321 step = ff_adpcm_step_table[c->step_index];
406 10327321 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];
407 10327321 step_index = av_clip(step_index, 0, 88);
408
409 10327321 sign = nibble & 8;
410 10327321 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 10327321 diff = ((2 * delta + 1) * step) >> shift;
415 10327321 predictor = c->predictor;
416
2/2
✓ Branch 0 taken 5115828 times.
✓ Branch 1 taken 5211493 times.
 10327321 if (sign) predictor -= diff;
417 5211493 else predictor += diff;
418
419 10327321 c->predictor = av_clip_int16(predictor);
420 10327321 c->step_index = step_index;
421
422 10327321 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_zero_extend(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 2233434 static inline int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
534 {
535 int predictor;
536
537 2233434 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
538
2/2
✓ Branch 0 taken 973371 times.
✓ Branch 1 taken 1260063 times.
 2233434 predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
539
540 2233434 c->sample2 = c->sample1;
541 2233434 c->sample1 = av_clip_int16(predictor);
542 2233434 c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
543
2/2
✓ Branch 0 taken 92703 times.
✓ Branch 1 taken 2140731 times.
 2233434 if (c->idelta < 16) c->idelta = 16;
544
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2233434 times.
 2233434 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 2233434 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 37705 static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
847 int buf_size, int *coded_samples, int *approx_nb_samples)
848 {
849 37705 ADPCMDecodeContext *s = avctx->priv_data;
850 37705 int nb_samples = 0;
851 37705 int ch = avctx->ch_layout.nb_channels;
852 37705 int has_coded_samples = 0;
853 int header_size;
854
855 37705 *coded_samples = 0;
856 37705 *approx_nb_samples = 0;
857
858
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37705 times.
 37705 if(ch <= 0)
859 ✗ return 0;
860
861
4/4
✓ Branch 0 taken 600 times.
✓ Branch 1 taken 26342 times.
✓ Branch 2 taken 1195 times.
✓ Branch 3 taken 9568 times.
 37705 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 1195 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 1195 nb_samples = buf_size * 2 / ch;
887 1195 break;
888 }
889
2/2
✓ Branch 0 taken 28137 times.
✓ Branch 1 taken 9568 times.
 37705 if (nb_samples)
890 28137 return nb_samples;
891
892 /* simple 4-bit adpcm, with header */
893 9568 header_size = 0;
894
3/3
✓ Branch 0 taken 145 times.
✓ Branch 1 taken 350 times.
✓ Branch 2 taken 9073 times.
 9568 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 9073 times.
 9568 if (header_size > 0)
904 495 return (buf_size - header_size) * 2 / ch;
905
906 /* more complex formats */
907
17/21
✓ Branch 0 taken 170 times.
✓ Branch 1 taken 158 times.
✓ Branch 2 taken 47 times.
✓ Branch 3 taken 39 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 2950 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.
 9073 switch (avctx->codec->id) {
908 170 case AV_CODEC_ID_ADPCM_IMA_AMV:
909 170 bytestream2_skip(gb, 4);
910 170 has_coded_samples = 1;
911 170 *coded_samples = bytestream2_get_le32u(gb);
912 170 nb_samples = FFMIN((buf_size - 8) * 2, *coded_samples);
913 170 bytestream2_seek(gb, -8, SEEK_CUR);
914 170 break;
915 158 case AV_CODEC_ID_ADPCM_EA:
916 /* Stereo is 30 bytes per block */
917 /* Mono is 15 bytes per block */
918 158 has_coded_samples = 1;
919 158 *coded_samples = bytestream2_get_le32(gb);
920 158 *coded_samples -= *coded_samples % 28;
921
1/2
✓ Branch 0 taken 158 times.
✗ Branch 1 not taken.
 158 nb_samples = (buf_size - 12) / (ch == 2 ? 30 : 15) * 28;
922 158 break;
923 47 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
924 47 has_coded_samples = 1;
925 47 *coded_samples = bytestream2_get_le32(gb);
926 47 nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;
927 47 break;
928 39 case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
929 39 nb_samples = (buf_size - ch) / ch * 2;
930 39 break;
931 400 case AV_CODEC_ID_ADPCM_EA_R1:
932 case AV_CODEC_ID_ADPCM_EA_R2:
933 case AV_CODEC_ID_ADPCM_EA_R3:
934 /* maximum number of samples */
935 /* has internal offsets and a per-frame switch to signal raw 16-bit */
936 400 has_coded_samples = 1;
937
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) {
938 95 case AV_CODEC_ID_ADPCM_EA_R1:
939 95 header_size = 4 + 9 * ch;
940 95 *coded_samples = bytestream2_get_le32(gb);
941 95 break;
942 180 case AV_CODEC_ID_ADPCM_EA_R2:
943 180 header_size = 4 + 5 * ch;
944 180 *coded_samples = bytestream2_get_le32(gb);
945 180 break;
946 125 case AV_CODEC_ID_ADPCM_EA_R3:
947 125 header_size = 4 + 5 * ch;
948 125 *coded_samples = bytestream2_get_be32(gb);
949 125 break;
950 }
951 400 *coded_samples -= *coded_samples % 28;
952 400 nb_samples = (buf_size - header_size) * 2 / ch;
953 400 nb_samples -= nb_samples % 28;
954 400 *approx_nb_samples = 1;
955 400 break;
956 642 case AV_CODEC_ID_ADPCM_IMA_DK3:
957
1/2
✓ Branch 0 taken 642 times.
✗ Branch 1 not taken.
 642 if (avctx->block_align > 0)
958 642 buf_size = FFMIN(buf_size, avctx->block_align);
959 642 nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;
960 642 break;
961 649 case AV_CODEC_ID_ADPCM_IMA_DK4:
962
1/2
✓ Branch 0 taken 649 times.
✗ Branch 1 not taken.
 649 if (avctx->block_align > 0)
963 649 buf_size = FFMIN(buf_size, avctx->block_align);
964
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 649 times.
 649 if (buf_size < 4 * ch)
965 ✗ return AVERROR_INVALIDDATA;
966 649 nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;
967 649 break;
968 1000 case AV_CODEC_ID_ADPCM_IMA_RAD:
969
1/2
✓ Branch 0 taken 1000 times.
✗ Branch 1 not taken.
 1000 if (avctx->block_align > 0)
970 1000 buf_size = FFMIN(buf_size, avctx->block_align);
971 1000 nb_samples = (buf_size - 4 * ch) * 2 / ch;
972 1000 break;
973
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,
974 int bsize = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
975 int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
976 if (avctx->block_align > 0)
977 buf_size = FFMIN(buf_size, avctx->block_align);
978 if (buf_size < 4 * ch)
979 return AVERROR_INVALIDDATA;
980 nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;
981 ) /* End of CASE */
982 2950 case AV_CODEC_ID_ADPCM_MS:
983
1/2
✓ Branch 0 taken 2950 times.
✗ Branch 1 not taken.
 2950 if (avctx->block_align > 0)
984 2950 buf_size = FFMIN(buf_size, avctx->block_align);
985 2950 nb_samples = (buf_size - 6 * ch) * 2 / ch;
986 2950 break;
987 ✗ case AV_CODEC_ID_ADPCM_MTAF:
988 ✗ if (avctx->block_align > 0)
989 ✗ buf_size = FFMIN(buf_size, avctx->block_align);
990 ✗ nb_samples = (buf_size - 16 * (ch / 2)) * 2 / ch;
991 ✗ break;
992 57 case AV_CODEC_ID_ADPCM_SBPRO_2:
993 case AV_CODEC_ID_ADPCM_SBPRO_3:
994 case AV_CODEC_ID_ADPCM_SBPRO_4:
995 {
996 int samples_per_byte;
997
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) {
998 13 case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;
999 18 case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;
1000 26 case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;
1001 }
1002
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 54 times.
 57 if (!s->status[0].step_index) {
1003
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (buf_size < ch)
1004 ✗ return AVERROR_INVALIDDATA;
1005 3 nb_samples++;
1006 3 buf_size -= ch;
1007 }
1008 57 nb_samples += buf_size * samples_per_byte / ch;
1009 57 break;
1010 }
1011 195 case AV_CODEC_ID_ADPCM_SWF:
1012 {
1013 195 int buf_bits = buf_size * 8 - 2;
1014 195 int nbits = (bytestream2_get_byte(gb) >> 6) + 2;
1015 195 int block_hdr_size = 22 * ch;
1016 195 int block_size = block_hdr_size + nbits * ch * 4095;
1017 195 int nblocks = buf_bits / block_size;
1018 195 int bits_left = buf_bits - nblocks * block_size;
1019 195 nb_samples = nblocks * 4096;
1020
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 195 times.
 195 if (bits_left >= block_hdr_size)
1021 ✗ nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);
1022 195 break;
1023 }
1024 71 case AV_CODEC_ID_ADPCM_THP:
1025 case AV_CODEC_ID_ADPCM_THP_LE:
1026
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
 71 if (avctx->extradata) {
1027 ✗ nb_samples = buf_size * 14 / (8 * ch);
1028 ✗ break;
1029 }
1030 71 has_coded_samples = 1;
1031 71 bytestream2_skip(gb, 4); // channel size
1032 142 *coded_samples = (avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE) ?
1033
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
 142 bytestream2_get_le32(gb) :
1034 71 bytestream2_get_be32(gb);
1035 71 buf_size -= 8 + 36 * ch;
1036 71 buf_size /= ch;
1037 71 nb_samples = buf_size / 8 * 14;
1038
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
 71 if (buf_size % 8 > 1)
1039 ✗ nb_samples += (buf_size % 8 - 1) * 2;
1040 71 *approx_nb_samples = 1;
1041 71 break;
1042 12 case AV_CODEC_ID_ADPCM_AFC:
1043 12 nb_samples = buf_size / (9 * ch) * 16;
1044 12 break;
1045 37 case AV_CODEC_ID_ADPCM_XA:
1046 37 nb_samples = (buf_size / 128) * 224 / ch;
1047 37 break;
1048 ✗ case AV_CODEC_ID_ADPCM_XMD:
1049 ✗ nb_samples = buf_size / (21 * ch) * 32;
1050 ✗ break;
1051 32 case AV_CODEC_ID_ADPCM_DTK:
1052 case AV_CODEC_ID_ADPCM_PSX:
1053 32 nb_samples = buf_size / (16 * ch) * 28;
1054 32 break;
1055 946 case AV_CODEC_ID_ADPCM_ARGO:
1056 946 nb_samples = buf_size / avctx->block_align * 32;
1057 946 break;
1058 ✗ case AV_CODEC_ID_ADPCM_ZORK:
1059 ✗ nb_samples = buf_size / ch;
1060 ✗ break;
1061 }
1062
1063 /* validate coded sample count */
1064
4/6
✓ Branch 0 taken 846 times.
✓ Branch 1 taken 8227 times.
✓ Branch 2 taken 846 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 846 times.
 9073 if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))
1065 ✗ return AVERROR_INVALIDDATA;
1066
1067 9073 return nb_samples;
1068 }
1069
1070 37705 static int adpcm_decode_frame(AVCodecContext *avctx, AVFrame *frame,
1071 int *got_frame_ptr, AVPacket *avpkt)
1072 {
1073 37705 const uint8_t *buf = avpkt->data;
1074 37705 int buf_size = avpkt->size;
1075 37705 ADPCMDecodeContext *c = avctx->priv_data;
1076 37705 int channels = avctx->ch_layout.nb_channels;
1077 int16_t *samples;
1078 int16_t **samples_p;
1079 int st; /* stereo */
1080 int nb_samples, coded_samples, approx_nb_samples, ret;
1081 GetByteContext gb;
1082
1083 37705 bytestream2_init(&gb, buf, buf_size);
1084 37705 nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);
1085
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37705 times.
 37705 if (nb_samples <= 0) {
1086 ✗ av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
1087 ✗ return AVERROR_INVALIDDATA;
1088 }
1089
1090 /* get output buffer */
1091 37705 frame->nb_samples = nb_samples;
1092
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 37705 times.
 37705 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1093 ✗ return ret;
1094 37705 samples = (int16_t *)frame->data[0];
1095 37705 samples_p = (int16_t **)frame->extended_data;
1096
1097 /* use coded_samples when applicable */
1098 /* it is always <= nb_samples, so the output buffer will be large enough */
1099
2/2
✓ Branch 0 taken 846 times.
✓ Branch 1 taken 36859 times.
 37705 if (coded_samples) {
1100
3/4
✓ Branch 0 taken 375 times.
✓ Branch 1 taken 471 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 375 times.
 846 if (!approx_nb_samples && coded_samples != nb_samples)
1101 ✗ av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
1102 846 frame->nb_samples = nb_samples = coded_samples;
1103 }
1104
1105 37705 st = channels == 2 ? 1 : 0;
1106
1107
32/43
✓ Branch 0 taken 26342 times.
✓ Branch 1 taken 1668 times.
✓ Branch 2 taken 26 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2950 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 54 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 39 times.
✓ Branch 25 taken 400 times.
✓ Branch 26 taken 600 times.
✗ Branch 27 not taken.
✓ Branch 28 taken 170 times.
✓ Branch 29 taken 350 times.
✓ Branch 30 taken 128 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.
 37705 switch(avctx->codec->id) {
1108
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,
1109 /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
1110 Channel data is interleaved per-chunk. */
1111 for (int channel = 0; channel < channels; channel++) {
1112 ADPCMChannelStatus *cs = &c->status[channel];
1113 int predictor;
1114 int step_index;
1115 /* (pppppp) (piiiiiii) */
1116
1117 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
1118 predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
1119 step_index = predictor & 0x7F;
1120 predictor &= ~0x7F;
1121
1122 if (cs->step_index == step_index) {
1123 int diff = predictor - cs->predictor;
1124 if (diff < 0)
1125 diff = - diff;
1126 if (diff > 0x7f)
1127 goto update;
1128 } else {
1129 update:
1130 cs->step_index = step_index;
1131 cs->predictor = predictor;
1132 }
1133
1134 if (cs->step_index > 88u){
1135 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1136 channel, cs->step_index);
1137 return AVERROR_INVALIDDATA;
1138 }
1139
1140 samples = samples_p[channel];
1141
1142 for (int m = 0; m < 64; m += 2) {
1143 int byte = bytestream2_get_byteu(&gb);
1144 samples[m ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F);
1145 samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4 );
1146 }
1147 }
1148 ) /* End of CASE */
1149
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,
1150 for (int i = 0; i < channels; i++) {
1151 ADPCMChannelStatus *cs = &c->status[i];
1152 cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);
1153
1154 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1155 if (cs->step_index > 88u){
1156 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1157 i, cs->step_index);
1158 return AVERROR_INVALIDDATA;
1159 }
1160 }
1161
1162 if (avctx->bits_per_coded_sample != 4) {
1163 int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];
1164 int block_size = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];
1165 uint8_t temp[20 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
1166 GetBitContext g;
1167
1168 for (int n = 0; n < (nb_samples - 1) / samples_per_block; n++) {
1169 for (int i = 0; i < channels; i++) {
1170 ADPCMChannelStatus *cs = &c->status[i];
1171 samples = &samples_p[i][1 + n * samples_per_block];
1172 for (int j = 0; j < block_size; j++) {
1173 temp[j] = buf[4 * channels + block_size * n * channels +
1174 (j % 4) + (j / 4) * (channels * 4) + i * 4];
1175 }
1176 ret = init_get_bits8(&g, (const uint8_t *)&temp, block_size);
1177 if (ret < 0)
1178 return ret;
1179 for (int m = 0; m < samples_per_block; m++) {
1180 samples[m] = adpcm_ima_wav_expand_nibble(cs, &g,
1181 avctx->bits_per_coded_sample);
1182 }
1183 }
1184 }
1185 bytestream2_skip(&gb, avctx->block_align - channels * 4);
1186 } else {
1187 for (int n = 0; n < (nb_samples - 1) / 8; n++) {
1188 for (int i = 0; i < channels; i++) {
1189 ADPCMChannelStatus *cs = &c->status[i];
1190 samples = &samples_p[i][1 + n * 8];
1191 for (int m = 0; m < 8; m += 2) {
1192 int v = bytestream2_get_byteu(&gb);
1193 samples[m ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1194 samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
1195 }
1196 }
1197 }
1198 }
1199 ) /* End of CASE */
1200
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,
1201 for (int i = 0; i < channels; i++)
1202 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1203
1204 for (int i = 0; i < channels; i++) {
1205 c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1206 if (c->status[i].step_index > 88u) {
1207 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1208 i, c->status[i].step_index);
1209 return AVERROR_INVALIDDATA;
1210 }
1211 }
1212
1213 for (int i = 0; i < channels; i++) {
1214 ADPCMChannelStatus *cs = &c->status[i];
1215 samples = (int16_t *)frame->data[i];
1216 for (int n = nb_samples >> 1; n > 0; n--) {
1217 int v = bytestream2_get_byteu(&gb);
1218 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
1219 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 4);
1220 }
1221 }
1222 ) /* End of CASE */
1223 ✗ CASE(ADPCM_AGM,
1224 for (int i = 0; i < channels; i++)
1225 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1226 for (int i = 0; i < channels; i++)
1227 c->status[i].step = sign_extend(bytestream2_get_le16u(&gb), 16);
1228
1229 for (int n = 0; n < nb_samples >> (1 - st); n++) {
1230 int v = bytestream2_get_byteu(&gb);
1231 *samples++ = adpcm_agm_expand_nibble(&c->status[0], v & 0xF);
1232 *samples++ = adpcm_agm_expand_nibble(&c->status[st], v >> 4 );
1233 }
1234 ) /* End of CASE */
1235
17/26
✗ Branch 0 not taken.
✓ Branch 1 taken 2950 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 2950 times.
✓ Branch 20 taken 2895 times.
✓ Branch 21 taken 55 times.
✗ Branch 23 not taken.
✓ Branch 24 taken 2895 times.
✓ Branch 27 taken 2895 times.
✓ Branch 28 taken 55 times.
✓ Branch 31 taken 2895 times.
✓ Branch 32 taken 55 times.
✓ Branch 35 taken 2895 times.
✓ Branch 36 taken 55 times.
✓ Branch 38 taken 2895 times.
✓ Branch 39 taken 55 times.
✓ Branch 40 taken 2895 times.
✓ Branch 41 taken 55 times.
✓ Branch 45 taken 1116717 times.
✓ Branch 46 taken 2950 times.
 1119667 CASE(ADPCM_MS,
1236 int block_predictor;
1237
1238 if (avctx->ch_layout.nb_channels > 2) {
1239 for (int channel = 0; channel < avctx->ch_layout.nb_channels; channel++) {
1240 samples = samples_p[channel];
1241 block_predictor = bytestream2_get_byteu(&gb);
1242 if (block_predictor > 6) {
1243 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[%d] = %d\n",
1244 channel, block_predictor);
1245 return AVERROR_INVALIDDATA;
1246 }
1247 c->status[channel].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1248 c->status[channel].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1249 c->status[channel].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1250 c->status[channel].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1251 c->status[channel].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1252 *samples++ = c->status[channel].sample2;
1253 *samples++ = c->status[channel].sample1;
1254 for (int n = (nb_samples - 2) >> 1; n > 0; n--) {
1255 int byte = bytestream2_get_byteu(&gb);
1256 *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte >> 4 );
1257 *samples++ = adpcm_ms_expand_nibble(&c->status[channel], byte & 0x0F);
1258 }
1259 }
1260 } else {
1261 block_predictor = bytestream2_get_byteu(&gb);
1262 if (block_predictor > 6) {
1263 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
1264 block_predictor);
1265 return AVERROR_INVALIDDATA;
1266 }
1267 c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1268 c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1269 if (st) {
1270 block_predictor = bytestream2_get_byteu(&gb);
1271 if (block_predictor > 6) {
1272 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
1273 block_predictor);
1274 return AVERROR_INVALIDDATA;
1275 }
1276 c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
1277 c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
1278 }
1279 c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1280 if (st){
1281 c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
1282 }
1283
1284 c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1285 if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
1286 c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1287 if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
1288
1289 *samples++ = c->status[0].sample2;
1290 if (st) *samples++ = c->status[1].sample2;
1291 *samples++ = c->status[0].sample1;
1292 if (st) *samples++ = c->status[1].sample1;
1293 for (int n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
1294 int byte = bytestream2_get_byteu(&gb);
1295 *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4 );
1296 *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
1297 }
1298 }
1299 ) /* End of CASE */
1300 ✗ CASE(ADPCM_MTAF,
1301 for (int channel = 0; channel < channels; channel += 2) {
1302 bytestream2_skipu(&gb, 4);
1303 c->status[channel ].step = bytestream2_get_le16u(&gb) & 0x1f;
1304 c->status[channel + 1].step = bytestream2_get_le16u(&gb) & 0x1f;
1305 c->status[channel ].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1306 bytestream2_skipu(&gb, 2);
1307 c->status[channel + 1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1308 bytestream2_skipu(&gb, 2);
1309 for (int n = 0; n < nb_samples; n += 2) {
1310 int v = bytestream2_get_byteu(&gb);
1311 samples_p[channel][n ] = adpcm_mtaf_expand_nibble(&c->status[channel], v & 0x0F);
1312 samples_p[channel][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel], v >> 4 );
1313 }
1314 for (int n = 0; n < nb_samples; n += 2) {
1315 int v = bytestream2_get_byteu(&gb);
1316 samples_p[channel + 1][n ] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v & 0x0F);
1317 samples_p[channel + 1][n + 1] = adpcm_mtaf_expand_nibble(&c->status[channel + 1], v >> 4 );
1318 }
1319 }
1320 ) /* End of CASE */
1321
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,
1322 for (int channel = 0; channel < channels; channel++) {
1323 ADPCMChannelStatus *cs = &c->status[channel];
1324 cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);
1325 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1326 if (cs->step_index > 88u){
1327 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1328 channel, cs->step_index);
1329 return AVERROR_INVALIDDATA;
1330 }
1331 }
1332 for (int n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
1333 int v = bytestream2_get_byteu(&gb);
1334 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3);
1335 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1336 }
1337 ) /* End of CASE */
1338
1339 /* DK3 ADPCM support macro */
1340 #define DK3_GET_NEXT_NIBBLE() \
1341 if (decode_top_nibble_next) { \
1342 nibble = last_byte >> 4; \
1343 decode_top_nibble_next = 0; \
1344 } else { \
1345 last_byte = bytestream2_get_byteu(&gb); \
1346 nibble = last_byte & 0x0F; \
1347 decode_top_nibble_next = 1; \
1348 }
1349
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,
1350 int last_byte = 0;
1351 int nibble;
1352 int decode_top_nibble_next = 0;
1353 int diff_channel;
1354 const int16_t *samples_end = samples + channels * nb_samples;
1355
1356 bytestream2_skipu(&gb, 10);
1357 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1358 c->status[1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1359 c->status[0].step_index = bytestream2_get_byteu(&gb);
1360 c->status[1].step_index = bytestream2_get_byteu(&gb);
1361 if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
1362 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
1363 c->status[0].step_index, c->status[1].step_index);
1364 return AVERROR_INVALIDDATA;
1365 }
1366 /* sign extend the predictors */
1367 diff_channel = c->status[1].predictor;
1368
1369 while (samples < samples_end) {
1370
1371 /* for this algorithm, c->status[0] is the sum channel and
1372 * c->status[1] is the diff channel */
1373
1374 /* process the first predictor of the sum channel */
1375 DK3_GET_NEXT_NIBBLE();
1376 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1377
1378 /* process the diff channel predictor */
1379 DK3_GET_NEXT_NIBBLE();
1380 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
1381
1382 /* process the first pair of stereo PCM samples */
1383 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1384 *samples++ = c->status[0].predictor + c->status[1].predictor;
1385 *samples++ = c->status[0].predictor - c->status[1].predictor;
1386
1387 /* process the second predictor of the sum channel */
1388 DK3_GET_NEXT_NIBBLE();
1389 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
1390
1391 /* process the second pair of stereo PCM samples */
1392 diff_channel = (diff_channel + c->status[1].predictor) / 2;
1393 *samples++ = c->status[0].predictor + c->status[1].predictor;
1394 *samples++ = c->status[0].predictor - c->status[1].predictor;
1395 }
1396
1397 if ((bytestream2_tell(&gb) & 1))
1398 bytestream2_skip(&gb, 1);
1399 ) /* End of CASE */
1400
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,
1401 for (int channel = 0; channel < channels; channel++) {
1402 ADPCMChannelStatus *cs = &c->status[channel];
1403 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1404 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1405 if (cs->step_index > 88u){
1406 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1407 channel, cs->step_index);
1408 return AVERROR_INVALIDDATA;
1409 }
1410 }
1411
1412 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1413 int v1, v2;
1414 int v = bytestream2_get_byteu(&gb);
1415 /* nibbles are swapped for mono */
1416 if (st) {
1417 v1 = v >> 4;
1418 v2 = v & 0x0F;
1419 } else {
1420 v2 = v >> 4;
1421 v1 = v & 0x0F;
1422 }
1423 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
1424 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
1425 }
1426 ) /* End of CASE */
1427 ✗ CASE(ADPCM_IMA_MOFLEX,
1428 for (int channel = 0; channel < channels; channel++) {
1429 ADPCMChannelStatus *cs = &c->status[channel];
1430 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1431 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1432 if (cs->step_index > 88u){
1433 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1434 channel, cs->step_index);
1435 return AVERROR_INVALIDDATA;
1436 }
1437 }
1438
1439 for (int subframe = 0; subframe < nb_samples / 256; subframe++) {
1440 for (int channel = 0; channel < channels; channel++) {
1441 samples = samples_p[channel] + 256 * subframe;
1442 for (int n = 0; n < 256; n += 2) {
1443 int v = bytestream2_get_byteu(&gb);
1444 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1445 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1446 }
1447 }
1448 }
1449 ) /* End of CASE */
1450 ✗ CASE(ADPCM_IMA_DAT4,
1451 for (int channel = 0; channel < channels; channel++) {
1452 ADPCMChannelStatus *cs = &c->status[channel];
1453 samples = samples_p[channel];
1454 bytestream2_skip(&gb, 4);
1455 for (int n = 0; n < nb_samples; n += 2) {
1456 int v = bytestream2_get_byteu(&gb);
1457 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
1458 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
1459 }
1460 }
1461 ) /* End of CASE */
1462
2/2
✓ Branch 3 taken 732060 times.
✓ Branch 4 taken 179 times.
 732239 CASE(ADPCM_IMA_APC,
1463 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1464 int v = bytestream2_get_byteu(&gb);
1465 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
1466 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
1467 }
1468 ) /* End of CASE */
1469
2/2
✓ Branch 3 taken 514600 times.
✓ Branch 4 taken 127 times.
 514727 CASE(ADPCM_IMA_SSI,
1470 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1471 int v = bytestream2_get_byteu(&gb);
1472 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0], v >> 4 );
1473 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0x0F);
1474 }
1475 ) /* End of CASE */
1476
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,
1477 for (int n = nb_samples / 2; n > 0; n--) {
1478 for (int channel = 0; channel < channels; channel++) {
1479 int v = bytestream2_get_byteu(&gb);
1480 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[channel], v >> 4 );
1481 samples[st] = adpcm_ima_qt_expand_nibble(&c->status[channel], v & 0x0F);
1482 }
1483 samples += channels;
1484 }
1485 ) /* End of CASE */
1486
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,
1487 for (int n = nb_samples / 2; n > 0; n--) {
1488 for (int channel = 0; channel < channels; channel++) {
1489 int v = bytestream2_get_byteu(&gb);
1490 *samples++ = adpcm_ima_alp_expand_nibble(&c->status[channel], v >> 4 , 2);
1491 samples[st] = adpcm_ima_alp_expand_nibble(&c->status[channel], v & 0x0F, 2);
1492 }
1493 samples += channels;
1494 }
1495 ) /* End of CASE */
1496
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,
1497 for (int channel = 0; channel < channels; channel++) {
1498 int16_t *smp = samples_p[channel];
1499 for (int n = 0; n < nb_samples / 2; n++) {
1500 int v = bytestream2_get_byteu(&gb);
1501 *smp++ = adpcm_ima_cunning_expand_nibble(&c->status[channel], v & 0x0F);
1502 *smp++ = adpcm_ima_cunning_expand_nibble(&c->status[channel], v >> 4);
1503 }
1504 }
1505 ) /* End of CASE */
1506
2/2
✓ Branch 3 taken 27562 times.
✓ Branch 4 taken 54 times.
 27616 CASE(ADPCM_IMA_OKI,
1507 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1508 int v = bytestream2_get_byteu(&gb);
1509 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[0], v >> 4 );
1510 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[st], v & 0x0F);
1511 }
1512 ) /* End of CASE */
1513
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,
1514 for (int channel = 0; channel < channels; channel++) {
1515 ADPCMChannelStatus *cs = &c->status[channel];
1516 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);
1517 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1518 if (cs->step_index > 88u){
1519 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1520 channel, cs->step_index);
1521 return AVERROR_INVALIDDATA;
1522 }
1523 }
1524 for (int n = 0; n < nb_samples / 2; n++) {
1525 int byte[2];
1526
1527 byte[0] = bytestream2_get_byteu(&gb);
1528 if (st)
1529 byte[1] = bytestream2_get_byteu(&gb);
1530 for (int channel = 0; channel < channels; channel++) {
1531 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] & 0x0F, 3);
1532 }
1533 for (int channel = 0; channel < channels; channel++) {
1534 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] >> 4 , 3);
1535 }
1536 }
1537 ) /* End of CASE */
1538
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,
1539 if (c->vqa_version == 3) {
1540 for (int channel = 0; channel < channels; channel++) {
1541 int16_t *smp = samples_p[channel];
1542
1543 for (int n = nb_samples / 2; n > 0; n--) {
1544 int v = bytestream2_get_byteu(&gb);
1545 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1546 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1547 }
1548 }
1549 } else {
1550 for (int n = nb_samples / 2; n > 0; n--) {
1551 for (int channel = 0; channel < channels; channel++) {
1552 int v = bytestream2_get_byteu(&gb);
1553 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);
1554 samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
1555 }
1556 samples += channels;
1557 }
1558 }
1559 bytestream2_seek(&gb, 0, SEEK_END);
1560 ) /* End of CASE */
1561 ✗ CASE(ADPCM_XMD,
1562 int bytes_remaining, block = 0;
1563 while (bytestream2_get_bytes_left(&gb) >= 21 * channels) {
1564 for (int channel = 0; channel < channels; channel++) {
1565 int16_t *out = samples_p[channel] + block * 32;
1566 int16_t history[2];
1567 uint16_t scale;
1568
1569 history[1] = sign_extend(bytestream2_get_le16(&gb), 16);
1570 history[0] = sign_extend(bytestream2_get_le16(&gb), 16);
1571 scale = bytestream2_get_le16(&gb);
1572
1573 out[0] = history[1];
1574 out[1] = history[0];
1575
1576 for (int n = 0; n < 15; n++) {
1577 unsigned byte = bytestream2_get_byte(&gb);
1578 int32_t nibble[2];
1579
1580 nibble[0] = sign_extend(byte & 15, 4);
1581 nibble[1] = sign_extend(byte >> 4, 4);
1582
1583 out[2+n*2] = nibble[0]*scale + ((history[0]*3667 - history[1]*1642) >> 11);
1584 history[1] = history[0];
1585 history[0] = out[2+n*2];
1586
1587 out[2+n*2+1] = nibble[1]*scale + ((history[0]*3667 - history[1]*1642) >> 11);
1588 history[1] = history[0];
1589 history[0] = out[2+n*2+1];
1590 }
1591 }
1592
1593 block++;
1594 }
1595 bytes_remaining = bytestream2_get_bytes_left(&gb);
1596 if (bytes_remaining > 0) {
1597 bytestream2_skip(&gb, bytes_remaining);
1598 }
1599 ) /* End of CASE */
1600
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,
1601 int16_t *out0 = samples_p[0];
1602 int16_t *out1 = samples_p[1];
1603 int samples_per_block = 28 * (3 - channels) * 4;
1604 int sample_offset = 0;
1605 int bytes_remaining;
1606 while (bytestream2_get_bytes_left(&gb) >= 128) {
1607 if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),
1608 &c->status[0], &c->status[1],
1609 channels, sample_offset)) < 0)
1610 return ret;
1611 bytestream2_skipu(&gb, 128);
1612 sample_offset += samples_per_block;
1613 }
1614 /* Less than a full block of data left, e.g. when reading from
1615 * 2324 byte per sector XA; the remainder is padding */
1616 bytes_remaining = bytestream2_get_bytes_left(&gb);
1617 if (bytes_remaining > 0) {
1618 bytestream2_skip(&gb, bytes_remaining);
1619 }
1620 ) /* End of CASE */
1621
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,
1622 for (int i = 0; i <= st; i++) {
1623 c->status[i].step_index = bytestream2_get_le32u(&gb);
1624 if (c->status[i].step_index > 88u) {
1625 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1626 i, c->status[i].step_index);
1627 return AVERROR_INVALIDDATA;
1628 }
1629 }
1630 for (int i = 0; i <= st; i++) {
1631 c->status[i].predictor = bytestream2_get_le32u(&gb);
1632 if (FFABS((int64_t)c->status[i].predictor) > (1<<16))
1633 return AVERROR_INVALIDDATA;
1634 }
1635
1636 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1637 int byte = bytestream2_get_byteu(&gb);
1638 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 3);
1639 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);
1640 }
1641 ) /* End of CASE */
1642
2/2
✓ Branch 3 taken 71392 times.
✓ Branch 4 taken 49 times.
 71441 CASE(ADPCM_IMA_EA_SEAD,
1643 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1644 int byte = bytestream2_get_byteu(&gb);
1645 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);
1646 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);
1647 }
1648 ) /* End of CASE */
1649
9/16
✗ Branch 0 not taken.
✓ Branch 1 taken 158 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 9 taken 8296 times.
✗ Branch 10 not taken.
✓ Branch 13 taken 232288 times.
✗ Branch 14 not taken.
✓ Branch 15 taken 240584 times.
✗ Branch 16 not taken.
✓ Branch 17 taken 232288 times.
✓ Branch 18 taken 8296 times.
✓ Branch 19 taken 8296 times.
✓ Branch 20 taken 158 times.
✓ Branch 21 taken 158 times.
✗ Branch 22 not taken.
 240742 CASE(ADPCM_EA,
1650 int previous_left_sample, previous_right_sample;
1651 int current_left_sample, current_right_sample;
1652 int next_left_sample, next_right_sample;
1653 int coeff1l, coeff2l, coeff1r, coeff2r;
1654 int shift_left, shift_right;
1655
1656 /* Each EA ADPCM frame has a 12-byte header followed by 30-byte (stereo) or 15-byte (mono) pieces,
1657 each coding 28 stereo/mono samples. */
1658
1659 if (channels != 2 && channels != 1)
1660 return AVERROR_INVALIDDATA;
1661
1662 current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1663 previous_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1664 current_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1665 previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);
1666
1667 for (int count1 = 0; count1 < nb_samples / 28; count1++) {
1668 int byte = bytestream2_get_byteu(&gb);
1669 coeff1l = ea_adpcm_table[ byte >> 4 ];
1670 coeff2l = ea_adpcm_table[(byte >> 4 ) + 4];
1671 coeff1r = ea_adpcm_table[ byte & 0x0F];
1672 coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];
1673
1674 if (channels == 2){
1675 byte = bytestream2_get_byteu(&gb);
1676 shift_left = 20 - (byte >> 4);
1677 shift_right = 20 - (byte & 0x0F);
1678 } else{
1679 /* Mono packs the shift into the coefficient byte's lower nibble instead */
1680 shift_left = 20 - (byte & 0x0F);
1681 }
1682
1683 for (int count2 = 0; count2 < (channels == 2 ? 28 : 14); count2++) {
1684 byte = bytestream2_get_byteu(&gb);
1685 next_left_sample = sign_extend(byte >> 4, 4) * (1 << shift_left);
1686
1687 next_left_sample = (next_left_sample +
1688 (current_left_sample * coeff1l) +
1689 (previous_left_sample * coeff2l) + 0x80) >> 8;
1690
1691 previous_left_sample = current_left_sample;
1692 current_left_sample = av_clip_int16(next_left_sample);
1693 *samples++ = current_left_sample;
1694
1695 if (channels == 2){
1696 next_right_sample = sign_extend(byte, 4) * (1 << shift_right);
1697
1698 next_right_sample = (next_right_sample +
1699 (current_right_sample * coeff1r) +
1700 (previous_right_sample * coeff2r) + 0x80) >> 8;
1701
1702 previous_right_sample = current_right_sample;
1703 current_right_sample = av_clip_int16(next_right_sample);
1704 *samples++ = current_right_sample;
1705 } else {
1706 next_left_sample = sign_extend(byte, 4) * (1 << shift_left);
1707
1708 next_left_sample = (next_left_sample +
1709 (current_left_sample * coeff1l) +
1710 (previous_left_sample * coeff2l) + 0x80) >> 8;
1711
1712 previous_left_sample = current_left_sample;
1713 current_left_sample = av_clip_int16(next_left_sample);
1714
1715 *samples++ = current_left_sample;
1716 }
1717 }
1718 }
1719 bytestream2_skip(&gb, channels == 2 ? 2 : 3); // Skip terminating NULs
1720 ) /* End of CASE */
1721
11/12
✓ Branch 1 taken 156 times.
✓ Branch 2 taken 78 times.
✓ Branch 3 taken 78 times.
✓ Branch 4 taken 39 times.
✓ Branch 6 taken 546 times.
✗ Branch 7 not taken.
✓ Branch 9 taken 2184 times.
✓ Branch 10 taken 1092 times.
✓ Branch 11 taken 1092 times.
✓ Branch 12 taken 546 times.
✓ Branch 13 taken 546 times.
✓ Branch 14 taken 39 times.
 4095 CASE(ADPCM_EA_MAXIS_XA,
1722 int coeff[2][2], shift[2];
1723
1724 for (int channel = 0; channel < channels; channel++) {
1725 int byte = bytestream2_get_byteu(&gb);
1726 for (int i = 0; i < 2; i++)
1727 coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
1728 shift[channel] = 20 - (byte & 0x0F);
1729 }
1730 for (int count1 = 0; count1 < nb_samples / 2; count1++) {
1731 int byte[2];
1732
1733 byte[0] = bytestream2_get_byteu(&gb);
1734 if (st) byte[1] = bytestream2_get_byteu(&gb);
1735 for (int i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
1736 for (int channel = 0; channel < channels; channel++) {
1737 int sample = sign_extend(byte[channel] >> i, 4) * (1 << shift[channel]);
1738 sample = (sample +
1739 c->status[channel].sample1 * coeff[channel][0] +
1740 c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
1741 c->status[channel].sample2 = c->status[channel].sample1;
1742 c->status[channel].sample1 = av_clip_int16(sample);
1743 *samples++ = c->status[channel].sample1;
1744 }
1745 }
1746 }
1747 bytestream2_seek(&gb, 0, SEEK_END);
1748 ) /* End of CASE */
1749 #if CONFIG_ADPCM_EA_R1_DECODER || CONFIG_ADPCM_EA_R2_DECODER || CONFIG_ADPCM_EA_R3_DECODER
1750 400 case AV_CODEC_ID_ADPCM_EA_R1:
1751 case AV_CODEC_ID_ADPCM_EA_R2:
1752 case AV_CODEC_ID_ADPCM_EA_R3: {
1753 /* channel numbering
1754 2chan: 0=fl, 1=fr
1755 4chan: 0=fl, 1=rl, 2=fr, 3=rr
1756 6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */
1757 400 const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
1758 int previous_sample, current_sample, next_sample;
1759 int coeff1, coeff2;
1760 int shift;
1761 uint16_t *samplesC;
1762 400 int count = 0;
1763 int offsets[6];
1764
1765
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 400 times.
 1200 for (unsigned channel = 0; channel < channels; channel++)
1766
2/2
✓ Branch 0 taken 250 times.
✓ Branch 1 taken 550 times.
 800 offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :
1767 550 bytestream2_get_le32(&gb)) +
1768 800 (channels + 1) * 4;
1769
1770
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 400 times.
 1200 for (unsigned channel = 0; channel < channels; channel++) {
1771 int count1;
1772
1773 800 bytestream2_seek(&gb, offsets[channel], SEEK_SET);
1774 800 samplesC = samples_p[channel];
1775
1776
2/2
✓ Branch 0 taken 190 times.
✓ Branch 1 taken 610 times.
 800 if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
1777 190 current_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1778 190 previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);
1779 } else {
1780 610 current_sample = c->status[channel].predictor;
1781 610 previous_sample = c->status[channel].prev_sample;
1782 }
1783
1784
2/2
✓ Branch 0 taken 41192 times.
✓ Branch 1 taken 800 times.
 41992 for (count1 = 0; count1 < nb_samples / 28; count1++) {
1785 41192 int byte = bytestream2_get_byte(&gb);
1786
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 41180 times.
 41192 if (byte == 0xEE) { /* only seen in R2 and R3 */
1787 12 current_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1788 12 previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);
1789
1790
2/2
✓ Branch 0 taken 336 times.
✓ Branch 1 taken 12 times.
 348 for (int count2 = 0; count2 < 28; count2++)
1791 336 *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);
1792 } else {
1793 41180 coeff1 = ea_adpcm_table[ byte >> 4 ];
1794 41180 coeff2 = ea_adpcm_table[(byte >> 4) + 4];
1795 41180 shift = 20 - (byte & 0x0F);
1796
1797
2/2
✓ Branch 0 taken 1153040 times.
✓ Branch 1 taken 41180 times.
 1194220 for (int count2 = 0; count2 < 28; count2++) {
1798
2/2
✓ Branch 0 taken 576520 times.
✓ Branch 1 taken 576520 times.
 1153040 if (count2 & 1)
1799 576520 next_sample = (unsigned)sign_extend(byte, 4) << shift;
1800 else {
1801 576520 byte = bytestream2_get_byte(&gb);
1802 576520 next_sample = (unsigned)sign_extend(byte >> 4, 4) << shift;
1803 }
1804
1805 1153040 next_sample += (current_sample * coeff1) +
1806 1153040 (previous_sample * coeff2);
1807 1153040 next_sample = av_clip_int16(next_sample >> 8);
1808
1809 1153040 previous_sample = current_sample;
1810 1153040 current_sample = next_sample;
1811 1153040 *samplesC++ = current_sample;
1812 }
1813 }
1814 }
1815
2/2
✓ Branch 0 taken 400 times.
✓ Branch 1 taken 400 times.
 800 if (!count) {
1816 400 count = count1;
1817
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 400 times.
 400 } else if (count != count1) {
1818 ✗ av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
1819 ✗ count = FFMAX(count, count1);
1820 }
1821
1822
2/2
✓ Branch 0 taken 610 times.
✓ Branch 1 taken 190 times.
 800 if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
1823 610 c->status[channel].predictor = current_sample;
1824 610 c->status[channel].prev_sample = previous_sample;
1825 }
1826 }
1827
1828 400 frame->nb_samples = count * 28;
1829 400 bytestream2_seek(&gb, 0, SEEK_END);
1830 400 break;
1831 }
1832 #endif /* CONFIG_ADPCM_EA_Rx_DECODER */
1833
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,
1834 for (int channel=0; channel < channels; channel++) {
1835 int coeff[2][4], shift[4];
1836 int16_t *s = samples_p[channel];
1837 for (int n = 0; n < 4; n++, s += 32) {
1838 int val = sign_extend(bytestream2_get_le16u(&gb), 16);
1839 for (int i = 0; i < 2; i++)
1840 coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];
1841 s[0] = val & ~0x0F;
1842
1843 val = sign_extend(bytestream2_get_le16u(&gb), 16);
1844 shift[n] = 20 - (val & 0x0F);
1845 s[1] = val & ~0x0F;
1846 }
1847
1848 for (int m = 2; m < 32; m += 2) {
1849 s = &samples_p[channel][m];
1850 for (int n = 0; n < 4; n++, s += 32) {
1851 int level, pred;
1852 int byte = bytestream2_get_byteu(&gb);
1853
1854 level = sign_extend(byte >> 4, 4) * (1 << shift[n]);
1855 pred = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];
1856 s[0] = av_clip_int16((level + pred + 0x80) >> 8);
1857
1858 level = sign_extend(byte, 4) * (1 << shift[n]);
1859 pred = s[0] * coeff[0][n] + s[-1] * coeff[1][n];
1860 s[1] = av_clip_int16((level + pred + 0x80) >> 8);
1861 }
1862 }
1863 }
1864 ) /* End of CASE */
1865 ✗ CASE(ADPCM_IMA_ACORN,
1866 for (int channel = 0; channel < channels; channel++) {
1867 ADPCMChannelStatus *cs = &c->status[channel];
1868 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1869 cs->step_index = bytestream2_get_le16u(&gb) & 0xFF;
1870 if (cs->step_index > 88u){
1871 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
1872 channel, cs->step_index);
1873 return AVERROR_INVALIDDATA;
1874 }
1875 }
1876 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1877 int byte = bytestream2_get_byteu(&gb);
1878 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte & 0x0F, 3);
1879 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte >> 4, 3);
1880 }
1881 ) /* End of CASE */
1882
7/10
✗ Branch 0 not taken.
✓ Branch 1 taken 170 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 170 times.
✓ Branch 13 taken 117130 times.
✓ Branch 14 taken 170 times.
✓ Branch 15 taken 23 times.
✓ Branch 16 taken 147 times.
✗ Branch 19 not taken.
✓ Branch 20 taken 23 times.
 117300 CASE(ADPCM_IMA_AMV,
1883 av_assert0(channels == 1);
1884
1885 /*
1886 * Header format:
1887 * int16_t predictor;
1888 * uint8_t step_index;
1889 * uint8_t reserved;
1890 * uint32_t frame_size;
1891 *
1892 * Some implementations have step_index as 16-bits, but others
1893 * only use the lower 8 and store garbage in the upper 8.
1894 */
1895 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);
1896 c->status[0].step_index = bytestream2_get_byteu(&gb);
1897 bytestream2_skipu(&gb, 5);
1898 if (c->status[0].step_index > 88u) {
1899 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1900 c->status[0].step_index);
1901 return AVERROR_INVALIDDATA;
1902 }
1903
1904 for (int n = nb_samples >> 1; n > 0; n--) {
1905 int v = bytestream2_get_byteu(&gb);
1906
1907 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
1908 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v & 0xf, 3);
1909 }
1910
1911 if (nb_samples & 1) {
1912 int v = bytestream2_get_byteu(&gb);
1913 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);
1914
1915 if (v & 0x0F) {
1916 /* Holds true on all the http://samples.mplayerhq.hu/amv samples. */
1917 av_log(avctx, AV_LOG_WARNING, "Last nibble set on packet with odd sample count.\n");
1918 av_log(avctx, AV_LOG_WARNING, "Sample will be skipped.\n");
1919 }
1920 }
1921 ) /* End of CASE */
1922
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,
1923 for (int i = 0; i < channels; i++) {
1924 c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);
1925 c->status[i].step_index = bytestream2_get_byteu(&gb);
1926 bytestream2_skipu(&gb, 1);
1927 if (c->status[i].step_index > 88u) {
1928 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
1929 c->status[i].step_index);
1930 return AVERROR_INVALIDDATA;
1931 }
1932 }
1933
1934 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1935 int v = bytestream2_get_byteu(&gb);
1936
1937 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4 );
1938 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf);
1939 }
1940 ) /* End of CASE */
1941
2/2
✓ Branch 3 taken 262096 times.
✓ Branch 4 taken 128 times.
 262224 CASE(ADPCM_CT,
1942 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1943 int v = bytestream2_get_byteu(&gb);
1944 *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
1945 *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
1946 }
1947 ) /* End of CASE */
1948 #if CONFIG_ADPCM_SBPRO_2_DECODER || CONFIG_ADPCM_SBPRO_3_DECODER || \
1949 CONFIG_ADPCM_SBPRO_4_DECODER
1950 57 case AV_CODEC_ID_ADPCM_SBPRO_4:
1951 case AV_CODEC_ID_ADPCM_SBPRO_3:
1952 case AV_CODEC_ID_ADPCM_SBPRO_2:
1953
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 54 times.
 57 if (!c->status[0].step_index) {
1954 /* the first byte is a raw sample */
1955 3 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1956
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (st)
1957 ✗ *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);
1958 3 c->status[0].step_index = 1;
1959 3 nb_samples--;
1960 }
1961
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 31 times.
 57 if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
1962
2/2
✓ Branch 0 taken 52230 times.
✓ Branch 1 taken 26 times.
 52256 for (int n = nb_samples >> (1 - st); n > 0; n--) {
1963 52230 int byte = bytestream2_get_byteu(&gb);
1964 104460 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1965 52230 byte >> 4, 4, 0);
1966 52230 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1967 52230 byte & 0x0F, 4, 0);
1968 }
1969
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 13 times.
 31 } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
1970
2/2
✓ Branch 0 taken 34820 times.
✓ Branch 1 taken 18 times.
 34838 for (int n = (nb_samples<<st) / 3; n > 0; n--) {
1971 34820 int byte = bytestream2_get_byteu(&gb);
1972 69640 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1973 34820 byte >> 5 , 3, 0);
1974 69640 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1975 34820 (byte >> 2) & 0x07, 3, 0);
1976 34820 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1977 34820 byte & 0x03, 2, 0);
1978 }
1979 } else {
1980
2/2
✓ Branch 0 taken 26115 times.
✓ Branch 1 taken 13 times.
 26128 for (int n = nb_samples >> (2 - st); n > 0; n--) {
1981 26115 int byte = bytestream2_get_byteu(&gb);
1982 52230 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1983 26115 byte >> 6 , 2, 2);
1984 52230 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1985 26115 (byte >> 4) & 0x03, 2, 2);
1986 52230 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
1987 26115 (byte >> 2) & 0x03, 2, 2);
1988 26115 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
1989 26115 byte & 0x03, 2, 2);
1990 }
1991 }
1992 57 break;
1993 #endif /* CONFIG_ADPCM_SBPRO_x_DECODER */
1994 195 CASE(ADPCM_SWF,
1995 adpcm_swf_decode(avctx, buf, buf_size, samples);
1996 bytestream2_seek(&gb, 0, SEEK_END);
1997 ) /* End of CASE */
1998
2/2
✓ Branch 3 taken 552960 times.
✓ Branch 4 taken 136 times.
 553096 CASE(ADPCM_YAMAHA,
1999 for (int n = nb_samples >> (1 - st); n > 0; n--) {
2000 int v = bytestream2_get_byteu(&gb);
2001 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
2002 *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 );
2003 }
2004 ) /* End of CASE */
2005 ✗ CASE(ADPCM_AICA,
2006 for (int channel = 0; channel < channels; channel++) {
2007 samples = samples_p[channel];
2008 for (int n = nb_samples >> 1; n > 0; n--) {
2009 int v = bytestream2_get_byteu(&gb);
2010 *samples++ = adpcm_yamaha_expand_nibble(&c->status[channel], v & 0x0F);
2011 *samples++ = adpcm_yamaha_expand_nibble(&c->status[channel], v >> 4 );
2012 }
2013 }
2014 ) /* End of CASE */
2015
11/16
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 7 taken 215040 times.
✓ Branch 8 taken 215040 times.
✓ Branch 10 taken 430080 times.
✓ Branch 11 taken 26880 times.
✓ Branch 12 taken 26880 times.
✓ Branch 13 taken 24 times.
✓ Branch 14 taken 24 times.
✓ Branch 15 taken 12 times.
✓ Branch 16 taken 12 times.
✓ Branch 17 taken 12 times.
 457008 CASE(ADPCM_AFC,
2016 int samples_per_block;
2017 int blocks;
2018
2019 if (avctx->extradata && avctx->extradata_size == 1 && avctx->extradata[0]) {
2020 samples_per_block = avctx->extradata[0] / 16;
2021 blocks = nb_samples / avctx->extradata[0];
2022 } else {
2023 samples_per_block = nb_samples / 16;
2024 blocks = 1;
2025 }
2026
2027 for (int m = 0; m < blocks; m++) {
2028 for (int channel = 0; channel < channels; channel++) {
2029 int prev1 = c->status[channel].sample1;
2030 int prev2 = c->status[channel].sample2;
2031
2032 samples = samples_p[channel] + m * 16;
2033 /* Read in every sample for this channel. */
2034 for (int i = 0; i < samples_per_block; i++) {
2035 int byte = bytestream2_get_byteu(&gb);
2036 int scale = 1 << (byte >> 4);
2037 int index = byte & 0xf;
2038 int factor1 = afc_coeffs[0][index];
2039 int factor2 = afc_coeffs[1][index];
2040
2041 /* Decode 16 samples. */
2042 for (int n = 0; n < 16; n++) {
2043 int32_t sampledat;
2044
2045 if (n & 1) {
2046 sampledat = sign_extend(byte, 4);
2047 } else {
2048 byte = bytestream2_get_byteu(&gb);
2049 sampledat = sign_extend(byte >> 4, 4);
2050 }
2051
2052 sampledat = ((prev1 * factor1 + prev2 * factor2) >> 11) +
2053 sampledat * scale;
2054 *samples = av_clip_int16(sampledat);
2055 prev2 = prev1;
2056 prev1 = *samples++;
2057 }
2058 }
2059
2060 c->status[channel].sample1 = prev1;
2061 c->status[channel].sample2 = prev2;
2062 }
2063 }
2064 bytestream2_seek(&gb, 0, SEEK_END);
2065 ) /* End of CASE */
2066 #if CONFIG_ADPCM_THP_DECODER || CONFIG_ADPCM_THP_LE_DECODER
2067 71 case AV_CODEC_ID_ADPCM_THP:
2068 case AV_CODEC_ID_ADPCM_THP_LE:
2069 {
2070 int table[14][16];
2071
2072 #define THP_GET16(g) \
2073 sign_extend( \
2074 avctx->codec->id == AV_CODEC_ID_ADPCM_THP_LE ? \
2075 bytestream2_get_le16u(&(g)) : \
2076 bytestream2_get_be16u(&(g)), 16)
2077
2078
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
 71 if (avctx->extradata) {
2079 GetByteContext tb;
2080 ✗ if (avctx->extradata_size < 32 * channels) {
2081 ✗ av_log(avctx, AV_LOG_ERROR, "Missing coeff table\n");
2082 ✗ return AVERROR_INVALIDDATA;
2083 }
2084
2085 ✗ bytestream2_init(&tb, avctx->extradata, avctx->extradata_size);
2086 ✗ for (int i = 0; i < channels; i++)
2087 ✗ for (int n = 0; n < 16; n++)
2088 ✗ table[i][n] = THP_GET16(tb);
2089 } else {
2090
2/2
✓ Branch 0 taken 142 times.
✓ Branch 1 taken 71 times.
 213 for (int i = 0; i < channels; i++)
2091
2/2
✓ Branch 0 taken 2272 times.
✓ Branch 1 taken 142 times.
 2414 for (int n = 0; n < 16; n++)
2092
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2272 times.
 2272 table[i][n] = THP_GET16(gb);
2093
2094
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 70 times.
 71 if (!c->has_status) {
2095 /* Initialize the previous sample. */
2096
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 for (int i = 0; i < channels; i++) {
2097
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 c->status[i].sample1 = THP_GET16(gb);
2098
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 c->status[i].sample2 = THP_GET16(gb);
2099 }
2100 1 c->has_status = 1;
2101 } else {
2102 70 bytestream2_skip(&gb, channels * 4);
2103 }
2104 }
2105
2106
2/2
✓ Branch 0 taken 142 times.
✓ Branch 1 taken 71 times.
 213 for (int ch = 0; ch < channels; ch++) {
2107 142 samples = samples_p[ch];
2108
2109 /* Read in every sample for this channel. */
2110
2/2
✓ Branch 0 taken 10840 times.
✓ Branch 1 taken 142 times.
 10982 for (int i = 0; i < (nb_samples + 13) / 14; i++) {
2111 10840 int byte = bytestream2_get_byteu(&gb);
2112 10840 int index = (byte >> 4) & 7;
2113 10840 unsigned int exp = byte & 0x0F;
2114 10840 int64_t factor1 = table[ch][index * 2];
2115 10840 int64_t factor2 = table[ch][index * 2 + 1];
2116
2117 /* Decode 14 samples. */
2118
3/4
✓ Branch 0 taken 151760 times.
✓ Branch 1 taken 10840 times.
✓ Branch 2 taken 151760 times.
✗ Branch 3 not taken.
 162600 for (int n = 0; n < 14 && (i * 14 + n < nb_samples); n++) {
2119 int32_t sampledat;
2120
2121
2/2
✓ Branch 0 taken 75880 times.
✓ Branch 1 taken 75880 times.
 151760 if (n & 1) {
2122 75880 sampledat = sign_extend(byte, 4);
2123 } else {
2124 75880 byte = bytestream2_get_byteu(&gb);
2125 75880 sampledat = sign_extend(byte >> 4, 4);
2126 }
2127
2128 151760 sampledat = ((c->status[ch].sample1 * factor1
2129 151760 + c->status[ch].sample2 * factor2) >> 11) + sampledat * (1 << exp);
2130 151760 *samples = av_clip_int16(sampledat);
2131 151760 c->status[ch].sample2 = c->status[ch].sample1;
2132 151760 c->status[ch].sample1 = *samples++;
2133 }
2134 }
2135 }
2136 71 break;
2137 }
2138 #endif /* CONFIG_ADPCM_THP(_LE)_DECODER */
2139
16/16
✓ Branch 0 taken 1024 times.
✓ Branch 1 taken 1024 times.
✓ Branch 5 taken 3388 times.
✓ Branch 6 taken 50876 times.
✓ Branch 7 taken 2744 times.
✓ Branch 8 taken 336 times.
✓ Branch 10 taken 28672 times.
✓ Branch 11 taken 28672 times.
✓ Branch 12 taken 57344 times.
✓ Branch 13 taken 2048 times.
✓ Branch 14 taken 2048 times.
✓ Branch 15 taken 64 times.
✓ Branch 16 taken 32 times.
✓ Branch 17 taken 32 times.
✓ Branch 19 taken 64 times.
✓ Branch 20 taken 32 times.
 59488 CASE(ADPCM_DTK,
2140 for (int channel = 0; channel < channels; channel++) {
2141 samples = samples_p[channel];
2142
2143 /* Read in every sample for this channel. */
2144 for (int i = 0; i < nb_samples / 28; i++) {
2145 int byte, header;
2146 if (channel)
2147 bytestream2_skipu(&gb, 1);
2148 header = bytestream2_get_byteu(&gb);
2149 bytestream2_skipu(&gb, 3 - channel);
2150
2151 /* Decode 28 samples. */
2152 for (int n = 0; n < 28; n++) {
2153 int32_t sampledat, prev;
2154
2155 switch (header >> 4) {
2156 case 1:
2157 prev = (c->status[channel].sample1 * 0x3c);
2158 break;
2159 case 2:
2160 prev = (c->status[channel].sample1 * 0x73) - (c->status[channel].sample2 * 0x34);
2161 break;
2162 case 3:
2163 prev = (c->status[channel].sample1 * 0x62) - (c->status[channel].sample2 * 0x37);
2164 break;
2165 default:
2166 prev = 0;
2167 }
2168
2169 prev = av_clip_intp2((prev + 0x20) >> 6, 21);
2170
2171 byte = bytestream2_get_byteu(&gb);
2172 if (!channel)
2173 sampledat = sign_extend(byte, 4);
2174 else
2175 sampledat = sign_extend(byte >> 4, 4);
2176
2177 sampledat = ((sampledat * (1 << 12)) >> (header & 0xf)) * (1 << 6) + prev;
2178 *samples++ = av_clip_int16(sampledat >> 6);
2179 c->status[channel].sample2 = c->status[channel].sample1;
2180 c->status[channel].sample1 = sampledat;
2181 }
2182 }
2183 if (!channel)
2184 bytestream2_seek(&gb, 0, SEEK_SET);
2185 }
2186 ) /* End of CASE */
2187 ✗ CASE(ADPCM_PSX,
2188 for (int block = 0; block < avpkt->size / FFMAX(avctx->block_align, 16 * channels); block++) {
2189 int nb_samples_per_block = 28 * FFMAX(avctx->block_align, 16 * channels) / (16 * channels);
2190 for (int channel = 0; channel < channels; channel++) {
2191 samples = samples_p[channel] + block * nb_samples_per_block;
2192 av_assert0((block + 1) * nb_samples_per_block <= nb_samples);
2193
2194 /* Read in every sample for this channel. */
2195 for (int i = 0; i < nb_samples_per_block / 28; i++) {
2196 int filter, shift, flag, byte;
2197
2198 filter = bytestream2_get_byteu(&gb);
2199 shift = filter & 0xf;
2200 filter = filter >> 4;
2201 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table))
2202 return AVERROR_INVALIDDATA;
2203 flag = bytestream2_get_byteu(&gb) & 0x7;
2204
2205 /* Decode 28 samples. */
2206 for (int n = 0; n < 28; n++) {
2207 int sample = 0, scale;
2208
2209 if (n & 1) {
2210 scale = sign_extend(byte >> 4, 4);
2211 } else {
2212 byte = bytestream2_get_byteu(&gb);
2213 scale = sign_extend(byte, 4);
2214 }
2215
2216 if (flag < 0x07) {
2217 scale = scale * (1 << 12);
2218 sample = (int)((scale >> shift) + (c->status[channel].sample1 * xa_adpcm_table[filter][0] + c->status[channel].sample2 * xa_adpcm_table[filter][1]) / 64);
2219 }
2220 *samples++ = av_clip_int16(sample);
2221 c->status[channel].sample2 = c->status[channel].sample1;
2222 c->status[channel].sample1 = sample;
2223 }
2224 }
2225 }
2226 }
2227 ) /* End of CASE */
2228
6/6
✓ Branch 4 taken 747296 times.
✓ Branch 5 taken 46706 times.
✓ Branch 6 taken 46706 times.
✓ Branch 7 taken 30245 times.
✓ Branch 8 taken 30245 times.
✓ Branch 9 taken 946 times.
 825193 CASE(ADPCM_ARGO,
2229 /*
2230 * The format of each block:
2231 * uint8_t left_control;
2232 * uint4_t left_samples[nb_samples];
2233 * ---- and if stereo ----
2234 * uint8_t right_control;
2235 * uint4_t right_samples[nb_samples];
2236 *
2237 * Format of the control byte:
2238 * MSB [SSSSRDRR] LSB
2239 * S = (Shift Amount - 2)
2240 * D = Decoder flag.
2241 * R = Reserved
2242 *
2243 * Each block relies on the previous two samples of each channel.
2244 * They should be 0 initially.
2245 */
2246 for (int block = 0; block < avpkt->size / avctx->block_align; block++) {
2247 for (int channel = 0; channel < avctx->ch_layout.nb_channels; channel++) {
2248 ADPCMChannelStatus *cs = c->status + channel;
2249 int control, shift;
2250
2251 samples = samples_p[channel] + block * 32;
2252
2253 /* Get the control byte and decode the samples, 2 at a time. */
2254 control = bytestream2_get_byteu(&gb);
2255 shift = (control >> 4) + 2;
2256
2257 for (int n = 0; n < 16; n++) {
2258 int sample = bytestream2_get_byteu(&gb);
2259 *samples++ = ff_adpcm_argo_expand_nibble(cs, sample >> 4, shift, control & 0x04);
2260 *samples++ = ff_adpcm_argo_expand_nibble(cs, sample >> 0, shift, control & 0x04);
2261 }
2262 }
2263 }
2264 ) /* End of CASE */
2265 ✗ CASE(ADPCM_ZORK,
2266 for (int n = 0; n < nb_samples * channels; n++) {
2267 int v = bytestream2_get_byteu(&gb);
2268 *samples++ = adpcm_zork_expand_nibble(&c->status[n % channels], v);
2269 }
2270 ) /* End of CASE */
2271 ✗ CASE(ADPCM_IMA_MTF,
2272 for (int n = nb_samples / 2; n > 0; n--) {
2273 for (int channel = 0; channel < channels; channel++) {
2274 int v = bytestream2_get_byteu(&gb);
2275 *samples++ = adpcm_ima_mtf_expand_nibble(&c->status[channel], v >> 4);
2276 samples[st] = adpcm_ima_mtf_expand_nibble(&c->status[channel], v & 0x0F);
2277 }
2278 samples += channels;
2279 }
2280 ) /* End of CASE */
2281 ✗ default:
2282 ✗ av_assert0(0); // unsupported codec_id should not happen
2283 }
2284
2285
2/4
✓ Branch 0 taken 37705 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 37705 times.
 37705 if (avpkt->size && bytestream2_tell(&gb) == 0) {
2286 ✗ av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n");
2287 ✗ return AVERROR_INVALIDDATA;
2288 }
2289
2290 37705 *got_frame_ptr = 1;
2291
2292
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 37705 times.
 37705 if (avpkt->size < bytestream2_tell(&gb)) {
2293 ✗ av_log(avctx, AV_LOG_ERROR, "Overread of %d < %d\n", avpkt->size, bytestream2_tell(&gb));
2294 ✗ return avpkt->size;
2295 }
2296
2297 37705 return bytestream2_tell(&gb);
2298 }
2299
2300 187 static void adpcm_flush(AVCodecContext *avctx)
2301 {
2302 187 ADPCMDecodeContext *c = avctx->priv_data;
2303
2304 /* Just nuke the entire state and re-init. */
2305 187 memset(c, 0, sizeof(ADPCMDecodeContext));
2306
2307
5/5
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 168 times.
 187 switch(avctx->codec_id) {
2308 2 case AV_CODEC_ID_ADPCM_CT:
2309 2 c->status[0].step = c->status[1].step = 511;
2310 2 break;
2311
2312 3 case AV_CODEC_ID_ADPCM_IMA_APC:
2313
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
 3 if (avctx->extradata && avctx->extradata_size >= 8) {
2314 2 c->status[0].predictor = av_clip_intp2(AV_RL32(avctx->extradata ), 18);
2315 2 c->status[1].predictor = av_clip_intp2(AV_RL32(avctx->extradata + 4), 18);
2316 }
2317 3 break;
2318
2319 6 case AV_CODEC_ID_ADPCM_IMA_APM:
2320
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
 6 if (avctx->extradata && avctx->extradata_size >= 28) {
2321 6 c->status[0].predictor = av_clip_intp2(AV_RL32(avctx->extradata + 16), 18);
2322 6 c->status[0].step_index = av_clip(AV_RL32(avctx->extradata + 20), 0, 88);
2323 6 c->status[1].predictor = av_clip_intp2(AV_RL32(avctx->extradata + 4), 18);
2324 6 c->status[1].step_index = av_clip(AV_RL32(avctx->extradata + 8), 0, 88);
2325 }
2326 6 break;
2327
2328 8 case AV_CODEC_ID_ADPCM_IMA_WS:
2329
3/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
 8 if (avctx->extradata && avctx->extradata_size >= 2)
2330 5 c->vqa_version = AV_RL16(avctx->extradata);
2331 8 break;
2332 168 default:
2333 /* Other codecs may want to handle this during decoding. */
2334 168 c->has_status = 0;
2335 168 return;
2336 }
2337
2338 19 c->has_status = 1;
2339 }
2340
2341
2342 static const enum AVSampleFormat sample_fmts_s16[] = { AV_SAMPLE_FMT_S16,
2343 AV_SAMPLE_FMT_NONE };
2344 static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16P,
2345 AV_SAMPLE_FMT_NONE };
2346 static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16,
2347 AV_SAMPLE_FMT_S16P,
2348 AV_SAMPLE_FMT_NONE };
2349
2350 #define ADPCM_DECODER_0(id_, sample_fmts_, name_, long_name_)
2351 #define ADPCM_DECODER_1(id_, sample_fmts_, name_, long_name_) \
2352 const FFCodec ff_ ## name_ ## _decoder = { \
2353 .p.name = #name_, \
2354 CODEC_LONG_NAME(long_name_), \
2355 .p.type = AVMEDIA_TYPE_AUDIO, \
2356 .p.id = id_, \
2357 .p.capabilities = AV_CODEC_CAP_DR1, \
2358 .p.sample_fmts = sample_fmts_, \
2359 .priv_data_size = sizeof(ADPCMDecodeContext), \
2360 .init = adpcm_decode_init, \
2361 FF_CODEC_DECODE_CB(adpcm_decode_frame), \
2362 .flush = adpcm_flush, \
2363 };
2364 #define ADPCM_DECODER_2(enabled, codec_id, name, sample_fmts, long_name) \
2365 ADPCM_DECODER_ ## enabled(codec_id, name, sample_fmts, long_name)
2366 #define ADPCM_DECODER_3(config, codec_id, name, sample_fmts, long_name) \
2367 ADPCM_DECODER_2(config, codec_id, name, sample_fmts, long_name)
2368 #define ADPCM_DECODER(codec, name, sample_fmts, long_name) \
2369 ADPCM_DECODER_3(CONFIG_ ## codec ## _DECODER, AV_CODEC_ID_ ## codec, \
2370 name, sample_fmts, long_name)
2371
2372 /* Note: Do not forget to add new entries to the Makefile as well. */
2373 ADPCM_DECODER(ADPCM_4XM, sample_fmts_s16p, adpcm_4xm, "ADPCM 4X Movie")
2374 ADPCM_DECODER(ADPCM_AFC, sample_fmts_s16p, adpcm_afc, "ADPCM Nintendo Gamecube AFC")
2375 ADPCM_DECODER(ADPCM_AGM, sample_fmts_s16, adpcm_agm, "ADPCM AmuseGraphics Movie")
2376 ADPCM_DECODER(ADPCM_AICA, sample_fmts_s16p, adpcm_aica, "ADPCM Yamaha AICA")
2377 ADPCM_DECODER(ADPCM_ARGO, sample_fmts_s16p, adpcm_argo, "ADPCM Argonaut Games")
2378 ADPCM_DECODER(ADPCM_CT, sample_fmts_s16, adpcm_ct, "ADPCM Creative Technology")
2379 ADPCM_DECODER(ADPCM_DTK, sample_fmts_s16p, adpcm_dtk, "ADPCM Nintendo Gamecube DTK")
2380 ADPCM_DECODER(ADPCM_EA, sample_fmts_s16, adpcm_ea, "ADPCM Electronic Arts")
2381 ADPCM_DECODER(ADPCM_EA_MAXIS_XA, sample_fmts_s16, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA")
2382 ADPCM_DECODER(ADPCM_EA_R1, sample_fmts_s16p, adpcm_ea_r1, "ADPCM Electronic Arts R1")
2383 ADPCM_DECODER(ADPCM_EA_R2, sample_fmts_s16p, adpcm_ea_r2, "ADPCM Electronic Arts R2")
2384 ADPCM_DECODER(ADPCM_EA_R3, sample_fmts_s16p, adpcm_ea_r3, "ADPCM Electronic Arts R3")
2385 ADPCM_DECODER(ADPCM_EA_XAS, sample_fmts_s16p, adpcm_ea_xas, "ADPCM Electronic Arts XAS")
2386 ADPCM_DECODER(ADPCM_IMA_ACORN, sample_fmts_s16, adpcm_ima_acorn, "ADPCM IMA Acorn Replay")
2387 ADPCM_DECODER(ADPCM_IMA_AMV, sample_fmts_s16, adpcm_ima_amv, "ADPCM IMA AMV")
2388 ADPCM_DECODER(ADPCM_IMA_APC, sample_fmts_s16, adpcm_ima_apc, "ADPCM IMA CRYO APC")
2389 ADPCM_DECODER(ADPCM_IMA_APM, sample_fmts_s16, adpcm_ima_apm, "ADPCM IMA Ubisoft APM")
2390 ADPCM_DECODER(ADPCM_IMA_CUNNING, sample_fmts_s16p, adpcm_ima_cunning, "ADPCM IMA Cunning Developments")
2391 ADPCM_DECODER(ADPCM_IMA_DAT4, sample_fmts_s16, adpcm_ima_dat4, "ADPCM IMA Eurocom DAT4")
2392 ADPCM_DECODER(ADPCM_IMA_DK3, sample_fmts_s16, adpcm_ima_dk3, "ADPCM IMA Duck DK3")
2393 ADPCM_DECODER(ADPCM_IMA_DK4, sample_fmts_s16, adpcm_ima_dk4, "ADPCM IMA Duck DK4")
2394 ADPCM_DECODER(ADPCM_IMA_EA_EACS, sample_fmts_s16, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS")
2395 ADPCM_DECODER(ADPCM_IMA_EA_SEAD, sample_fmts_s16, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD")
2396 ADPCM_DECODER(ADPCM_IMA_ISS, sample_fmts_s16, adpcm_ima_iss, "ADPCM IMA Funcom ISS")
2397 ADPCM_DECODER(ADPCM_IMA_MOFLEX, sample_fmts_s16p, adpcm_ima_moflex, "ADPCM IMA MobiClip MOFLEX")
2398 ADPCM_DECODER(ADPCM_IMA_MTF, sample_fmts_s16, adpcm_ima_mtf, "ADPCM IMA Capcom's MT Framework")
2399 ADPCM_DECODER(ADPCM_IMA_OKI, sample_fmts_s16, adpcm_ima_oki, "ADPCM IMA Dialogic OKI")
2400 ADPCM_DECODER(ADPCM_IMA_QT, sample_fmts_s16p, adpcm_ima_qt, "ADPCM IMA QuickTime")
2401 ADPCM_DECODER(ADPCM_IMA_RAD, sample_fmts_s16, adpcm_ima_rad, "ADPCM IMA Radical")
2402 ADPCM_DECODER(ADPCM_IMA_SSI, sample_fmts_s16, adpcm_ima_ssi, "ADPCM IMA Simon & Schuster Interactive")
2403 ADPCM_DECODER(ADPCM_IMA_SMJPEG, sample_fmts_s16, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG")
2404 ADPCM_DECODER(ADPCM_IMA_ALP, sample_fmts_s16, adpcm_ima_alp, "ADPCM IMA High Voltage Software ALP")
2405 ADPCM_DECODER(ADPCM_IMA_WAV, sample_fmts_s16p, adpcm_ima_wav, "ADPCM IMA WAV")
2406 ADPCM_DECODER(ADPCM_IMA_WS, sample_fmts_both, adpcm_ima_ws, "ADPCM IMA Westwood")
2407 ADPCM_DECODER(ADPCM_MS, sample_fmts_both, adpcm_ms, "ADPCM Microsoft")
2408 ADPCM_DECODER(ADPCM_MTAF, sample_fmts_s16p, adpcm_mtaf, "ADPCM MTAF")
2409 ADPCM_DECODER(ADPCM_PSX, sample_fmts_s16p, adpcm_psx, "ADPCM Playstation")
2410 ADPCM_DECODER(ADPCM_SBPRO_2, sample_fmts_s16, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit")
2411 ADPCM_DECODER(ADPCM_SBPRO_3, sample_fmts_s16, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit")
2412 ADPCM_DECODER(ADPCM_SBPRO_4, sample_fmts_s16, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit")
2413 ADPCM_DECODER(ADPCM_SWF, sample_fmts_s16, adpcm_swf, "ADPCM Shockwave Flash")
2414 ADPCM_DECODER(ADPCM_THP_LE, sample_fmts_s16p, adpcm_thp_le, "ADPCM Nintendo THP (little-endian)")
2415 ADPCM_DECODER(ADPCM_THP, sample_fmts_s16p, adpcm_thp, "ADPCM Nintendo THP")
2416 ADPCM_DECODER(ADPCM_XA, sample_fmts_s16p, adpcm_xa, "ADPCM CDROM XA")
2417 ADPCM_DECODER(ADPCM_XMD, sample_fmts_s16p, adpcm_xmd, "ADPCM Konami XMD")
2418 ADPCM_DECODER(ADPCM_YAMAHA, sample_fmts_s16, adpcm_yamaha, "ADPCM Yamaha")
2419 ADPCM_DECODER(ADPCM_ZORK, sample_fmts_s16, adpcm_zork, "ADPCM Zork")
2420