FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/apv_entropy.c
Date: 2025-08-07 17:35:02
Exec Total Coverage
Lines: 309 339 91.2%
Functions: 3 3 100.0%
Branches: 137 156 87.8%
Line Branch Exec Source
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include "apv.h"
20 #include "apv_decode.h"
21
22 #include "put_bits.h"
23
24
25 av_always_inline
26 6639061 static unsigned int apv_read_vlc(GetBitContext *restrict gbc, int k_param,
27 const APVVLCLUT *restrict lut)
28 {
29 unsigned int next_bits;
30 const APVSingleVLCLUTEntry *ent;
31
32 6639061 next_bits = show_bits(gbc, APV_VLC_LUT_BITS);
33 6639061 ent = &lut->single_lut[k_param][next_bits];
34
35
2/2
✓ Branch 0 taken 366768 times.
✓ Branch 1 taken 6272293 times.
 6639061 if (ent->more) {
36 unsigned int leading_zeroes;
37
38 366768 skip_bits(gbc, ent->consume);
39
40 366768 next_bits = show_bits(gbc, 16);
41 366768 leading_zeroes = 15 - av_log2(next_bits);
42
43
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 366768 times.
 366768 if (leading_zeroes == 0) {
44 // This can't happen mid-stream because the lookup would
45 // have resolved a leading one into a shorter code, but it
46 // can happen if we are hitting the end of the buffer.
47 // Return an invalid code to propagate as an error.
48 ✗ return APV_MAX_TRANS_COEFF + 1;
49 }
50
51 366768 skip_bits(gbc, leading_zeroes + 1);
52
53 366768 return (2 << k_param) +
54 366768 ((1 << leading_zeroes) - 1) * (1 << k_param) +
55 366768 get_bits(gbc, leading_zeroes + k_param);
56 } else {
57 6272293 skip_bits(gbc, ent->consume);
58 6272293 return ent->result;
59 }
60 }
61
62 7 void ff_apv_entropy_build_decode_lut(APVVLCLUT *decode_lut)
63 {
64 7 const int code_len = APV_VLC_LUT_BITS;
65 7 const int lut_size = APV_VLC_LUT_SIZE;
66
67 // Build the single-symbol VLC table.
68
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 7 times.
 49 for (int k = 0; k <= 5; k++) {
69
2/2
✓ Branch 0 taken 21504 times.
✓ Branch 1 taken 42 times.
 21546 for (unsigned int code = 0; code < lut_size; code++) {
70 21504 APVSingleVLCLUTEntry *ent = &decode_lut->single_lut[k][code];
71 21504 unsigned int first_bit = code & (1 << code_len - 1);
72 21504 unsigned int remaining_bits = code ^ first_bit;
73
74
2/2
✓ Branch 0 taken 10752 times.
✓ Branch 1 taken 10752 times.
 21504 if (first_bit) {
75 10752 ent->consume = 1 + k;
76 10752 ent->result = remaining_bits >> (code_len - k - 1);
77 10752 ent->more = 0;
78 } else {
79 10752 unsigned int second_bit = code & (1 << code_len - 2);
80 10752 remaining_bits ^= second_bit;
81
82
2/2
✓ Branch 0 taken 5376 times.
✓ Branch 1 taken 5376 times.
 10752 if (second_bit) {
83 5376 unsigned int bits_left = code_len - 2;
84 5376 unsigned int first_set = bits_left - av_log2(remaining_bits);
85 5376 unsigned int last_bits = first_set - 1 + k;
86
87
2/2
✓ Branch 0 taken 4200 times.
✓ Branch 1 taken 1176 times.
 5376 if (first_set + last_bits <= bits_left) {
88 // Whole code fits here.
89 4200 ent->consume = 2 + first_set + last_bits;
90 4200 ent->result = ((2 << k) +
91 4200 (((1 << first_set - 1) - 1) << k) +
92 4200 ((code >> bits_left - first_set - last_bits) & (1 << last_bits) - 1));
93 4200 ent->more = 0;
94 } else {
95 // Need to read more, collapse to default.
96 1176 ent->consume = 2;
97 1176 ent->more = 1;
98 }
99 } else {
100 5376 ent->consume = 2 + k;
101 5376 ent->result = (1 << k) + (remaining_bits >> (code_len - k - 2));
102 5376 ent->more = 0;
103 }
104 }
105 }
106 }
107
108 // Build the multi-symbol VLC table.
109
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 7 times.
 28 for (int start_run = 0; start_run <= 2; start_run++) {
110
2/2
✓ Branch 0 taken 105 times.
✓ Branch 1 taken 21 times.
 126 for (int start_level = 0; start_level <= 4; start_level++) {
111
2/2
✓ Branch 0 taken 53760 times.
✓ Branch 1 taken 105 times.
 53865 for (unsigned int code = 0; code < lut_size; code++) {
112 APVMultiVLCLUTEntry *ent;
113 int k_run, k_level;
114 GetBitContext gbc;
115 PutBitContext pbc;
116 uint8_t buffer[16];
117 uint8_t run_first_buffer[16];
118 uint8_t level_first_buffer[16];
119
120 53760 memset(buffer, 0, sizeof(buffer));
121 53760 init_put_bits(&pbc, buffer, sizeof(buffer));
122 53760 put_bits(&pbc, APV_VLC_LUT_BITS, code);
123 53760 flush_put_bits(&pbc);
124
125 53760 memcpy(run_first_buffer, buffer, sizeof(buffer));
126 53760 memcpy(level_first_buffer, buffer, sizeof(buffer));
127
128 53760 k_run = start_run;
129 53760 k_level = start_level;
130
131 53760 ent = &decode_lut->run_first_lut[k_run][k_level][code];
132 53760 memset(ent, 0, sizeof(*ent));
133 53760 init_get_bits8(&gbc, run_first_buffer, sizeof(run_first_buffer));
134
135 53760 ent->count = 0;
136
2/2
✓ Branch 0 taken 92008 times.
✓ Branch 1 taken 6076 times.
 98084 for (int i = 0; i <= 1; i++) {
137 int value, sign, pos;
138
139 92008 value = apv_read_vlc(&gbc, k_run, decode_lut);
140 92008 pos = get_bits_count(&gbc);
141
2/2
✓ Branch 0 taken 17066 times.
✓ Branch 1 taken 74942 times.
 92008 if (pos > APV_VLC_LUT_BITS)
142 17066 break;
143 74942 ent->run[i] = value;
144 74942 ent->offset[ent->count] = pos;
145 74942 ++ent->count;
146 74942 k_run = FFMIN(value >> 2, 2);
147
148 74942 value = apv_read_vlc(&gbc, k_level, decode_lut);
149 74942 sign = get_bits1(&gbc);
150 74942 pos = get_bits_count(&gbc);
151
2/2
✓ Branch 0 taken 30618 times.
✓ Branch 1 taken 44324 times.
 74942 if (pos > APV_VLC_LUT_BITS)
152 30618 break;
153 44324 ++value;
154
2/2
✓ Branch 0 taken 22162 times.
✓ Branch 1 taken 22162 times.
 44324 ent->level[i] = sign ? -value : value;
155 44324 ent->offset[ent->count] = pos;
156 44324 ++ent->count;
157 44324 k_level = FFMIN(value >> 2, 4);
158
2/2
✓ Branch 0 taken 38248 times.
✓ Branch 1 taken 6076 times.
 44324 if (i == 0)
159 38248 ent->k_level_0 = k_level;
160 }
161
4/4
✓ Branch 0 taken 52360 times.
✓ Branch 1 taken 1400 times.
✓ Branch 2 taken 46284 times.
✓ Branch 3 taken 6076 times.
 53760 if (ent->count > 0 && ent->count < 4)
162 46284 ent->offset[3] = ent->offset[ent->count - 1];
163 53760 ent->k_run = k_run;
164 53760 ent->k_level_1 = k_level;
165
166 53760 k_run = start_run;
167 53760 k_level = start_level;
168
169 53760 ent = &decode_lut->level_first_lut[k_run][k_level][code];
170 53760 memset(ent, 0, sizeof(*ent));
171 53760 init_get_bits8(&gbc, level_first_buffer, sizeof(level_first_buffer));
172
173 53760 ent->count = 0;
174
2/2
✓ Branch 0 taken 92008 times.
✓ Branch 1 taken 6076 times.
 98084 for (int i = 0; i <= 1; i++) {
175 int value, sign, pos;
176
177 92008 value = apv_read_vlc(&gbc, k_level, decode_lut);
178 92008 sign = get_bits1(&gbc);
179 92008 pos = get_bits_count(&gbc);
180
2/2
✓ Branch 0 taken 27356 times.
✓ Branch 1 taken 64652 times.
 92008 if (pos > APV_VLC_LUT_BITS)
181 27356 break;
182 64652 ++value;
183
2/2
✓ Branch 0 taken 32326 times.
✓ Branch 1 taken 32326 times.
 64652 ent->level[i] = sign ? -value : value;
184 64652 ent->offset[ent->count] = pos;
185 64652 ++ent->count;
186 64652 k_level = FFMIN(value >> 2, 4);
187
2/2
✓ Branch 0 taken 50400 times.
✓ Branch 1 taken 14252 times.
 64652 if (i == 0)
188 50400 ent->k_level_0 = k_level;
189
190 64652 value = apv_read_vlc(&gbc, k_run, decode_lut);
191 64652 pos = get_bits_count(&gbc);
192
2/2
✓ Branch 0 taken 20328 times.
✓ Branch 1 taken 44324 times.
 64652 if (pos > APV_VLC_LUT_BITS)
193 20328 break;
194 44324 ent->run[i] = value;
195 44324 ent->offset[ent->count] = pos;
196 44324 ++ent->count;
197 44324 k_run = FFMIN(value >> 2, 2);
198 }
199
4/4
✓ Branch 0 taken 50400 times.
✓ Branch 1 taken 3360 times.
✓ Branch 2 taken 44324 times.
✓ Branch 3 taken 6076 times.
 53760 if (ent->count > 0 && ent->count < 4)
200 44324 ent->offset[3] = ent->offset[ent->count - 1];
201 53760 ent->k_run = k_run;
202 53760 ent->k_level_1 = k_level;
203 }
204 }
205 }
206 7 }
207
208 17380 int ff_apv_entropy_decode_block(int16_t *restrict coeff,
209 GetBitContext *restrict gbc,
210 APVEntropyState *restrict state)
211 {
212 17380 const APVVLCLUT *lut = state->decode_lut;
213 int scan_pos;
214 17380 int k_dc = state->prev_k_dc;
215 int k_run, k_level;
216 uint32_t next_bits, lut_bits;
217 const APVMultiVLCLUTEntry *ent;
218
219 // DC coefficient is likely to be large and cannot be usefully
220 // combined with other read steps, so extract it separately.
221 {
222 int dc_coeff, abs_diff, sign;
223
224 17380 abs_diff = apv_read_vlc(gbc, k_dc, lut);
225
226
2/2
✓ Branch 0 taken 16201 times.
✓ Branch 1 taken 1179 times.
 17380 if (abs_diff) {
227 16201 sign = get_bits1(gbc);
228
2/2
✓ Branch 0 taken 8230 times.
✓ Branch 1 taken 7971 times.
 16201 if (sign)
229 8230 dc_coeff = state->prev_dc - abs_diff;
230 else
231 7971 dc_coeff = state->prev_dc + abs_diff;
232 } else {
233 1179 dc_coeff = state->prev_dc;
234 }
235
236
237
2/4
✓ Branch 0 taken 17380 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 17380 times.
 17380 if (dc_coeff < APV_MIN_TRANS_COEFF ||
238 dc_coeff > APV_MAX_TRANS_COEFF) {
239 ✗ av_log(state->log_ctx, AV_LOG_ERROR,
240 "Out-of-range DC coefficient value: %d.\n",
241 dc_coeff);
242 ✗ return AVERROR_INVALIDDATA;
243 }
244
245 17380 coeff[0] = dc_coeff;
246
247 17380 state->prev_dc = dc_coeff;
248 17380 state->prev_k_dc = FFMIN(abs_diff >> 1, 5);
249 }
250
251 // Repeatedly read 18 bits, look up the first half of them in either
252 // the run-first or the level-first table. If the next code is too
253 // long the 18 bits will allow resolving a run code (up to 63)
254 // without reading any more bits, and will allow the exact length
255 // of a level code to be determined. (Note that reusing the
256 // single-symbol LUT is never useful here as the multisymbol lookup
257 // has already determined that the code is too long.)
258
259 // Run a single iteration of the run-first LUT to start, then a
260 // single iteration of the level-first LUT if that only read a
261 // single code. This avoids dealing with the first-AC logic inside
262 // the normal code lookup sequence.
263
264 17380 k_level = state->prev_k_level;
265 {
266 17380 next_bits = show_bits(gbc, 18);
267 17380 lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
268
269 17380 ent = &lut->run_first_lut[0][k_level][lut_bits];
270
271
2/2
✓ Branch 0 taken 973 times.
✓ Branch 1 taken 16407 times.
 17380 if (ent->count == 0) {
272 // One long code.
273 uint32_t bits, low_bits;
274 unsigned int leading_zeroes, low_bit_count, low_bit_shift;
275 int run;
276
277 // Remove the prefix bits.
278 973 bits = next_bits & 0xffff;
279 // Determine code length.
280 973 leading_zeroes = 15 - av_log2(bits);
281
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 973 times.
 973 if (leading_zeroes >= 6) {
282 // 6 zeroes implies run > 64, which is always invalid.
283 ✗ av_log(state->log_ctx, AV_LOG_ERROR,
284 "Out-of-range run value: %d leading zeroes.\n",
285 leading_zeroes);
286 ✗ return AVERROR_INVALIDDATA;
287 }
288 // Extract the low bits.
289 973 low_bit_count = leading_zeroes;
290 973 low_bit_shift = 16 - (1 + 2 * leading_zeroes);
291 973 low_bits = (bits >> low_bit_shift) & ((1 << low_bit_count) - 1);
292 // Construct run code.
293 973 run = 2 + ((1 << leading_zeroes) - 1) + low_bits;
294 // Skip over the bits just used.
295 973 skip_bits(gbc, 2 + leading_zeroes + 1 + low_bit_count);
296
297 973 scan_pos = run + 1;
298
2/2
✓ Branch 0 taken 958 times.
✓ Branch 1 taken 15 times.
 973 if (scan_pos >= 64)
299 958 goto end_of_block;
300 15 k_run = FFMIN(run >> 2, 2);
301 15 goto first_level;
302 } else {
303 // One or more short codes starting with a run; if there is
304 // a level code then the length needs to be saved for the
305 // next block.
306
307 16407 scan_pos = ent->run[0] + 1;
308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16407 times.
 16407 if (scan_pos >= 64) {
309 ✗ skip_bits(gbc, ent->offset[0]);
310 ✗ goto end_of_block;
311 }
312
2/2
✓ Branch 0 taken 13631 times.
✓ Branch 1 taken 2776 times.
 16407 if (ent->count > 1) {
313 13631 coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
314 13631 ++scan_pos;
315 13631 state->prev_k_level = ent->k_level_0;
316
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13631 times.
 13631 if (scan_pos >= 64) {
317 ✗ skip_bits(gbc, ent->offset[1]);
318 ✗ goto end_of_block;
319 }
320 }
321
2/2
✓ Branch 0 taken 10516 times.
✓ Branch 1 taken 5891 times.
 16407 if (ent->count > 2) {
322 10516 scan_pos += ent->run[1];
323
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10516 times.
 10516 if (scan_pos >= 64) {
324 ✗ skip_bits(gbc, ent->offset[2]);
325 ✗ goto end_of_block;
326 }
327 }
328
2/2
✓ Branch 0 taken 2449 times.
✓ Branch 1 taken 13958 times.
 16407 if (ent->count > 3) {
329 2449 coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
330 2449 ++scan_pos;
331
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2449 times.
 2449 if (scan_pos >= 64) {
332 ✗ skip_bits(gbc, ent->offset[3]);
333 ✗ goto end_of_block;
334 }
335 }
336 16407 skip_bits(gbc, ent->offset[3]);
337 16407 k_run = ent->k_run;
338 16407 k_level = ent->k_level_1;
339
2/2
✓ Branch 0 taken 2776 times.
✓ Branch 1 taken 13631 times.
 16407 if (ent->count == 1)
340 2776 goto first_level;
341
2/2
✓ Branch 0 taken 8067 times.
✓ Branch 1 taken 5564 times.
 13631 else if (ent->count & 1)
342 8067 goto next_is_level;
343 else
344 5564 goto next_is_run;
345 }
346 }
347
348 2791 first_level: {
349 2791 next_bits = show_bits(gbc, 18);
350 2791 lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
351
352 2791 ent = &lut->level_first_lut[k_run][k_level][lut_bits];
353
354
2/2
✓ Branch 0 taken 1957 times.
✓ Branch 1 taken 834 times.
 2791 if (ent->count == 0) {
355 // One long code.
356 uint32_t bits;
357 unsigned int leading_zeroes;
358 int level, abs_level, sign;
359
360 // Remove the prefix bits.
361 1957 bits = next_bits & 0xffff;
362 // Determine code length.
363 1957 leading_zeroes = 15 - av_log2(bits);
364 // Skip the prefix and length bits.
365 1957 skip_bits(gbc, 2 + leading_zeroes + 1);
366 // Read the rest of the code and construct the level.
367 // Include the + 1 offset for nonzero value here.
368 3914 abs_level = (2 << k_level) +
369 3914 ((1 << leading_zeroes) - 1) * (1 << k_level) +
370 1957 get_bits(gbc, leading_zeroes + k_level) + 1;
371
372 1957 sign = get_bits(gbc, 1);
373
2/2
✓ Branch 0 taken 916 times.
✓ Branch 1 taken 1041 times.
 1957 if (sign)
374 916 level = -abs_level;
375 else
376 1041 level = abs_level;
377
378 // Check range (not checked in any other case, only a long
379 // code can be out of range).
380
2/4
✓ Branch 0 taken 1957 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1957 times.
 1957 if (level < APV_MIN_TRANS_COEFF ||
381 level > APV_MAX_TRANS_COEFF) {
382 ✗ av_log(state->log_ctx, AV_LOG_ERROR,
383 "Out-of-range AC coefficient value at %d: %d.\n",
384 scan_pos, level);
385 ✗ return AVERROR_INVALIDDATA;
386 }
387 1957 coeff[ff_zigzag_direct[scan_pos]] = level;
388 1957 ++scan_pos;
389 1957 k_level = FFMIN(abs_level >> 2, 4);
390 1957 state->prev_k_level = k_level;
391
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1957 times.
 1957 if (scan_pos >= 64)
392 ✗ goto end_of_block;
393 1957 goto next_is_run;
394
395 } else {
396 // One or more short codes.
397
398 834 coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
399 834 ++scan_pos;
400 834 state->prev_k_level = ent->k_level_0;
401
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 834 times.
 834 if (scan_pos >= 64) {
402 ✗ skip_bits(gbc, ent->offset[0]);
403 ✗ goto end_of_block;
404 }
405
2/2
✓ Branch 0 taken 102 times.
✓ Branch 1 taken 732 times.
 834 if (ent->count > 1) {
406 102 scan_pos += ent->run[0];
407
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 102 times.
 102 if (scan_pos >= 64) {
408 ✗ skip_bits(gbc, ent->offset[1]);
409 ✗ goto end_of_block;
410 }
411 }
412
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 815 times.
 834 if (ent->count > 2) {
413 19 coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
414 19 ++scan_pos;
415
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
 19 if (scan_pos >= 64) {
416 ✗ skip_bits(gbc, ent->offset[2]);
417 ✗ goto end_of_block;
418 }
419 }
420
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 833 times.
 834 if (ent->count > 3) {
421 1 scan_pos += ent->run[1];
422
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (scan_pos >= 64) {
423 ✗ skip_bits(gbc, ent->offset[3]);
424 ✗ goto end_of_block;
425 }
426 }
427 834 skip_bits(gbc, ent->offset[3]);
428 834 k_run = ent->k_run;
429 834 k_level = ent->k_level_1;
430
2/2
✓ Branch 0 taken 750 times.
✓ Branch 1 taken 84 times.
 834 if (ent->count & 1)
431 750 goto next_is_run;
432 else
433 84 goto next_is_level;
434 }
435 }
436
437 64177 next_is_run: {
438 120589 next_bits = show_bits(gbc, 18);
439 120589 lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
440
441 120589 ent = &lut->run_first_lut[k_run][k_level][lut_bits];
442
443
2/2
✓ Branch 0 taken 5218 times.
✓ Branch 1 taken 115371 times.
 120589 if (ent->count == 0) {
444 // One long code.
445 uint32_t bits, low_bits;
446 unsigned int leading_zeroes, low_bit_count, low_bit_shift;
447 int run;
448
449 // Remove the prefix bits.
450 5218 bits = next_bits & 0xffff;
451 // Determine code length.
452 5218 leading_zeroes = 15 - av_log2(bits);
453
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5218 times.
 5218 if (leading_zeroes >= 6) {
454 // 6 zeroes implies run > 64, which is always invalid.
455 ✗ av_log(state->log_ctx, AV_LOG_ERROR,
456 "Out-of-range run value: %d leading zeroes.\n",
457 leading_zeroes);
458 ✗ return AVERROR_INVALIDDATA;
459 }
460 // Extract the low bits.
461 5218 low_bit_count = leading_zeroes + k_run;
462 5218 low_bit_shift = 16 - (1 + 2 * leading_zeroes + k_run);
463 5218 low_bits = (bits >> low_bit_shift) & ((1 << low_bit_count) - 1);
464 // Construct run code.
465 5218 run = (2 << k_run) +
466 5218 ((1 << leading_zeroes) - 1) * (1 << k_run) +
467 low_bits;
468 // Skip over the bits just used.
469 5218 skip_bits(gbc, 2 + leading_zeroes + 1 + low_bit_count);
470
471 5218 scan_pos += run;
472
2/2
✓ Branch 0 taken 4865 times.
✓ Branch 1 taken 353 times.
 5218 if (scan_pos >= 64)
473 4865 goto end_of_block;
474 353 k_run = FFMIN(run >> 2, 2);
475 353 goto next_is_level;
476
477 } else {
478 // One or more short codes.
479
480 115371 scan_pos += ent->run[0];
481
2/2
✓ Branch 0 taken 3859 times.
✓ Branch 1 taken 111512 times.
 115371 if (scan_pos >= 64) {
482 3859 skip_bits(gbc, ent->offset[0]);
483 3859 goto end_of_block;
484 }
485
2/2
✓ Branch 0 taken 103717 times.
✓ Branch 1 taken 7795 times.
 111512 if (ent->count > 1) {
486 103717 coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
487 103717 ++scan_pos;
488
2/2
✓ Branch 0 taken 1027 times.
✓ Branch 1 taken 102690 times.
 103717 if (scan_pos >= 64) {
489 1027 skip_bits(gbc, ent->offset[1]);
490 1027 goto end_of_block;
491 }
492 }
493
2/2
✓ Branch 0 taken 86236 times.
✓ Branch 1 taken 24249 times.
 110485 if (ent->count > 2) {
494 86236 scan_pos += ent->run[1];
495
2/2
✓ Branch 0 taken 779 times.
✓ Branch 1 taken 85457 times.
 86236 if (scan_pos >= 64) {
496 779 skip_bits(gbc, ent->offset[2]);
497 779 goto end_of_block;
498 }
499 }
500
2/2
✓ Branch 0 taken 40651 times.
✓ Branch 1 taken 69055 times.
 109706 if (ent->count > 3) {
501 40651 coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
502 40651 ++scan_pos;
503
2/2
✓ Branch 0 taken 693 times.
✓ Branch 1 taken 39958 times.
 40651 if (scan_pos >= 64) {
504 693 skip_bits(gbc, ent->offset[3]);
505 693 goto end_of_block;
506 }
507 }
508 109013 skip_bits(gbc, ent->offset[3]);
509 109013 k_run = ent->k_run;
510 109013 k_level = ent->k_level_1;
511
2/2
✓ Branch 0 taken 52601 times.
✓ Branch 1 taken 56412 times.
 109013 if (ent->count & 1)
512 52601 goto next_is_level;
513 else
514 56412 goto next_is_run;
515 }
516 }
517
518 61105 next_is_level: {
519 252892 next_bits = show_bits(gbc, 18);
520 252892 lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS);
521
522 252892 ent = &lut->level_first_lut[k_run][k_level][lut_bits];
523
524
2/2
✓ Branch 0 taken 11886 times.
✓ Branch 1 taken 241006 times.
 252892 if (ent->count == 0) {
525 // One long code.
526 uint32_t bits;
527 unsigned int leading_zeroes;
528 int level, abs_level, sign;
529
530 // Remove the prefix bits.
531 11886 bits = next_bits & 0xffff;
532 // Determine code length.
533 11886 leading_zeroes = 15 - av_log2(bits);
534 // Skip the prefix and length bits.
535 11886 skip_bits(gbc, 2 + leading_zeroes + 1);
536 // Read the rest of the code and construct the level.
537 // Include the + 1 offset for nonzero value here.
538 23772 abs_level = (2 << k_level) +
539 23772 ((1 << leading_zeroes) - 1) * (1 << k_level) +
540 11886 get_bits(gbc, leading_zeroes + k_level) + 1;
541
542 11886 sign = get_bits(gbc, 1);
543
2/2
✓ Branch 0 taken 5911 times.
✓ Branch 1 taken 5975 times.
 11886 if (sign)
544 5911 level = -abs_level;
545 else
546 5975 level = abs_level;
547
548 // Check range (not checked in any other case, only a long
549 // code can be out of range).
550
2/4
✓ Branch 0 taken 11886 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 11886 times.
 11886 if (level < APV_MIN_TRANS_COEFF ||
551 level > APV_MAX_TRANS_COEFF) {
552 ✗ av_log(state->log_ctx, AV_LOG_ERROR,
553 "Out-of-range AC coefficient value at %d: %d.\n",
554 scan_pos, level);
555 ✗ return AVERROR_INVALIDDATA;
556 }
557 11886 coeff[ff_zigzag_direct[scan_pos]] = level;
558 11886 ++scan_pos;
559 11886 k_level = FFMIN(abs_level >> 2, 4);
560
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 11862 times.
 11886 if (scan_pos >= 64)
561 24 goto end_of_block;
562 11862 goto next_is_run;
563
564 } else {
565 // One or more short codes.
566
567 241006 coeff[ff_zigzag_direct[scan_pos]] = ent->level[0];
568 241006 ++scan_pos;
569
2/2
✓ Branch 0 taken 1338 times.
✓ Branch 1 taken 239668 times.
 241006 if (scan_pos >= 64) {
570 1338 skip_bits(gbc, ent->offset[0]);
571 1338 goto end_of_block;
572 }
573
2/2
✓ Branch 0 taken 228456 times.
✓ Branch 1 taken 11212 times.
 239668 if (ent->count > 1) {
574 228456 scan_pos += ent->run[0];
575
2/2
✓ Branch 0 taken 1852 times.
✓ Branch 1 taken 226604 times.
 228456 if (scan_pos >= 64) {
576 1852 skip_bits(gbc, ent->offset[1]);
577 1852 goto end_of_block;
578 }
579 }
580
2/2
✓ Branch 0 taken 112618 times.
✓ Branch 1 taken 125198 times.
 237816 if (ent->count > 2) {
581 112618 coeff[ff_zigzag_direct[scan_pos]] = ent->level[1];
582 112618 ++scan_pos;
583
2/2
✓ Branch 0 taken 1306 times.
✓ Branch 1 taken 111312 times.
 112618 if (scan_pos >= 64) {
584 1306 skip_bits(gbc, ent->offset[2]);
585 1306 goto end_of_block;
586 }
587 }
588
2/2
✓ Branch 0 taken 78480 times.
✓ Branch 1 taken 158030 times.
 236510 if (ent->count > 3) {
589 78480 scan_pos += ent->run[1];
590
2/2
✓ Branch 0 taken 679 times.
✓ Branch 1 taken 77801 times.
 78480 if (scan_pos >= 64) {
591 679 skip_bits(gbc, ent->offset[3]);
592 679 goto end_of_block;
593 }
594 }
595 235831 skip_bits(gbc, ent->offset[3]);
596 235831 k_run = ent->k_run;
597 235831 k_level = ent->k_level_1;
598
2/2
✓ Branch 0 taken 44044 times.
✓ Branch 1 taken 191787 times.
 235831 if (ent->count & 1)
599 44044 goto next_is_run;
600 else
601 191787 goto next_is_level;
602 }
603 }
604
605 17380 end_of_block: {
606
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17380 times.
 17380 if (scan_pos > 64) {
607 ✗ av_log(state->log_ctx, AV_LOG_ERROR,
608 "Block decode reached invalid scan position %d.\n",
609 scan_pos);
610 ✗ return AVERROR_INVALIDDATA;
611 }
612 17380 return 0;
613 }
614 }
615