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 | 6542662 | 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 | 6542662 | next_bits = show_bits(gbc, APV_VLC_LUT_BITS); | |
33 | 6542662 | ent = &lut->single_lut[k_param][next_bits]; | |
34 | |||
35 |
2/2✓ Branch 0 taken 361006 times.
✓ Branch 1 taken 6181656 times.
|
6542662 | if (ent->more) { |
36 | unsigned int leading_zeroes; | ||
37 | |||
38 | 361006 | skip_bits(gbc, ent->consume); | |
39 | |||
40 | 361006 | next_bits = show_bits(gbc, 16); | |
41 | 361006 | leading_zeroes = 15 - av_log2(next_bits); | |
42 | |||
43 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 361006 times.
|
361006 | 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 | 361006 | skip_bits(gbc, leading_zeroes + 1); | |
52 | |||
53 | 361006 | return (2 << k_param) + | |
54 | 361006 | ((1 << leading_zeroes) - 1) * (1 << k_param) + | |
55 | 361006 | get_bits(gbc, leading_zeroes + k_param); | |
56 | } else { | ||
57 | 6181656 | skip_bits(gbc, ent->consume); | |
58 | 6181656 | return ent->result; | |
59 | } | ||
60 | } | ||
61 | |||
62 | 5 | void ff_apv_entropy_build_decode_lut(APVVLCLUT *decode_lut) | |
63 | { | ||
64 | 5 | const int code_len = APV_VLC_LUT_BITS; | |
65 | 5 | const int lut_size = APV_VLC_LUT_SIZE; | |
66 | |||
67 | // Build the single-symbol VLC table. | ||
68 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 5 times.
|
35 | for (int k = 0; k <= 5; k++) { |
69 |
2/2✓ Branch 0 taken 15360 times.
✓ Branch 1 taken 30 times.
|
15390 | for (unsigned int code = 0; code < lut_size; code++) { |
70 | 15360 | APVSingleVLCLUTEntry *ent = &decode_lut->single_lut[k][code]; | |
71 | 15360 | unsigned int first_bit = code & (1 << code_len - 1); | |
72 | 15360 | unsigned int remaining_bits = code ^ first_bit; | |
73 | |||
74 |
2/2✓ Branch 0 taken 7680 times.
✓ Branch 1 taken 7680 times.
|
15360 | if (first_bit) { |
75 | 7680 | ent->consume = 1 + k; | |
76 | 7680 | ent->result = remaining_bits >> (code_len - k - 1); | |
77 | 7680 | ent->more = 0; | |
78 | } else { | ||
79 | 7680 | unsigned int second_bit = code & (1 << code_len - 2); | |
80 | 7680 | remaining_bits ^= second_bit; | |
81 | |||
82 |
2/2✓ Branch 0 taken 3840 times.
✓ Branch 1 taken 3840 times.
|
7680 | if (second_bit) { |
83 | 3840 | unsigned int bits_left = code_len - 2; | |
84 | 3840 | unsigned int first_set = bits_left - av_log2(remaining_bits); | |
85 | 3840 | unsigned int last_bits = first_set - 1 + k; | |
86 | |||
87 |
2/2✓ Branch 0 taken 3000 times.
✓ Branch 1 taken 840 times.
|
3840 | if (first_set + last_bits <= bits_left) { |
88 | // Whole code fits here. | ||
89 | 3000 | ent->consume = 2 + first_set + last_bits; | |
90 | 3000 | ent->result = ((2 << k) + | |
91 | 3000 | (((1 << first_set - 1) - 1) << k) + | |
92 | 3000 | ((code >> bits_left - first_set - last_bits) & (1 << last_bits) - 1)); | |
93 | 3000 | ent->more = 0; | |
94 | } else { | ||
95 | // Need to read more, collapse to default. | ||
96 | 840 | ent->consume = 2; | |
97 | 840 | ent->more = 1; | |
98 | } | ||
99 | } else { | ||
100 | 3840 | ent->consume = 2 + k; | |
101 | 3840 | ent->result = (1 << k) + (remaining_bits >> (code_len - k - 2)); | |
102 | 3840 | ent->more = 0; | |
103 | } | ||
104 | } | ||
105 | } | ||
106 | } | ||
107 | |||
108 | // Build the multi-symbol VLC table. | ||
109 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 5 times.
|
20 | for (int start_run = 0; start_run <= 2; start_run++) { |
110 |
2/2✓ Branch 0 taken 75 times.
✓ Branch 1 taken 15 times.
|
90 | for (int start_level = 0; start_level <= 4; start_level++) { |
111 |
2/2✓ Branch 0 taken 38400 times.
✓ Branch 1 taken 75 times.
|
38475 | 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 | 38400 | memset(buffer, 0, sizeof(buffer)); | |
121 | 38400 | init_put_bits(&pbc, buffer, sizeof(buffer)); | |
122 | 38400 | put_bits(&pbc, APV_VLC_LUT_BITS, code); | |
123 | 38400 | flush_put_bits(&pbc); | |
124 | |||
125 | 38400 | memcpy(run_first_buffer, buffer, sizeof(buffer)); | |
126 | 38400 | memcpy(level_first_buffer, buffer, sizeof(buffer)); | |
127 | |||
128 | 38400 | k_run = start_run; | |
129 | 38400 | k_level = start_level; | |
130 | |||
131 | 38400 | ent = &decode_lut->run_first_lut[k_run][k_level][code]; | |
132 | 38400 | memset(ent, 0, sizeof(*ent)); | |
133 | 38400 | init_get_bits8(&gbc, run_first_buffer, sizeof(run_first_buffer)); | |
134 | |||
135 | 38400 | ent->count = 0; | |
136 |
2/2✓ Branch 0 taken 65720 times.
✓ Branch 1 taken 4340 times.
|
70060 | for (int i = 0; i <= 1; i++) { |
137 | int value, sign, pos; | ||
138 | |||
139 | 65720 | value = apv_read_vlc(&gbc, k_run, decode_lut); | |
140 | 65720 | pos = get_bits_count(&gbc); | |
141 |
2/2✓ Branch 0 taken 12190 times.
✓ Branch 1 taken 53530 times.
|
65720 | if (pos > APV_VLC_LUT_BITS) |
142 | 12190 | break; | |
143 | 53530 | ent->run[i] = value; | |
144 | 53530 | ent->offset[ent->count] = pos; | |
145 | 53530 | ++ent->count; | |
146 | 53530 | k_run = FFMIN(value >> 2, 2); | |
147 | |||
148 | 53530 | value = apv_read_vlc(&gbc, k_level, decode_lut); | |
149 | 53530 | sign = get_bits1(&gbc); | |
150 | 53530 | pos = get_bits_count(&gbc); | |
151 |
2/2✓ Branch 0 taken 21870 times.
✓ Branch 1 taken 31660 times.
|
53530 | if (pos > APV_VLC_LUT_BITS) |
152 | 21870 | break; | |
153 | 31660 | ++value; | |
154 |
2/2✓ Branch 0 taken 15830 times.
✓ Branch 1 taken 15830 times.
|
31660 | ent->level[i] = sign ? -value : value; |
155 | 31660 | ent->offset[ent->count] = pos; | |
156 | 31660 | ++ent->count; | |
157 | 31660 | k_level = FFMIN(value >> 2, 4); | |
158 |
2/2✓ Branch 0 taken 27320 times.
✓ Branch 1 taken 4340 times.
|
31660 | if (i == 0) |
159 | 27320 | ent->k_level_0 = k_level; | |
160 | } | ||
161 |
4/4✓ Branch 0 taken 37400 times.
✓ Branch 1 taken 1000 times.
✓ Branch 2 taken 33060 times.
✓ Branch 3 taken 4340 times.
|
38400 | if (ent->count > 0 && ent->count < 4) |
162 | 33060 | ent->offset[3] = ent->offset[ent->count - 1]; | |
163 | 38400 | ent->k_run = k_run; | |
164 | 38400 | ent->k_level_1 = k_level; | |
165 | |||
166 | 38400 | k_run = start_run; | |
167 | 38400 | k_level = start_level; | |
168 | |||
169 | 38400 | ent = &decode_lut->level_first_lut[k_run][k_level][code]; | |
170 | 38400 | memset(ent, 0, sizeof(*ent)); | |
171 | 38400 | init_get_bits8(&gbc, level_first_buffer, sizeof(level_first_buffer)); | |
172 | |||
173 | 38400 | ent->count = 0; | |
174 |
2/2✓ Branch 0 taken 65720 times.
✓ Branch 1 taken 4340 times.
|
70060 | for (int i = 0; i <= 1; i++) { |
175 | int value, sign, pos; | ||
176 | |||
177 | 65720 | value = apv_read_vlc(&gbc, k_level, decode_lut); | |
178 | 65720 | sign = get_bits1(&gbc); | |
179 | 65720 | pos = get_bits_count(&gbc); | |
180 |
2/2✓ Branch 0 taken 19540 times.
✓ Branch 1 taken 46180 times.
|
65720 | if (pos > APV_VLC_LUT_BITS) |
181 | 19540 | break; | |
182 | 46180 | ++value; | |
183 |
2/2✓ Branch 0 taken 23090 times.
✓ Branch 1 taken 23090 times.
|
46180 | ent->level[i] = sign ? -value : value; |
184 | 46180 | ent->offset[ent->count] = pos; | |
185 | 46180 | ++ent->count; | |
186 | 46180 | k_level = FFMIN(value >> 2, 4); | |
187 |
2/2✓ Branch 0 taken 36000 times.
✓ Branch 1 taken 10180 times.
|
46180 | if (i == 0) |
188 | 36000 | ent->k_level_0 = k_level; | |
189 | |||
190 | 46180 | value = apv_read_vlc(&gbc, k_run, decode_lut); | |
191 | 46180 | pos = get_bits_count(&gbc); | |
192 |
2/2✓ Branch 0 taken 14520 times.
✓ Branch 1 taken 31660 times.
|
46180 | if (pos > APV_VLC_LUT_BITS) |
193 | 14520 | break; | |
194 | 31660 | ent->run[i] = value; | |
195 | 31660 | ent->offset[ent->count] = pos; | |
196 | 31660 | ++ent->count; | |
197 | 31660 | k_run = FFMIN(value >> 2, 2); | |
198 | } | ||
199 |
4/4✓ Branch 0 taken 36000 times.
✓ Branch 1 taken 2400 times.
✓ Branch 2 taken 31660 times.
✓ Branch 3 taken 4340 times.
|
38400 | if (ent->count > 0 && ent->count < 4) |
200 | 31660 | ent->offset[3] = ent->offset[ent->count - 1]; | |
201 | 38400 | ent->k_run = k_run; | |
202 | 38400 | ent->k_level_1 = k_level; | |
203 | } | ||
204 | } | ||
205 | } | ||
206 | 5 | } | |
207 | |||
208 | 13540 | int ff_apv_entropy_decode_block(int16_t *restrict coeff, | |
209 | GetBitContext *restrict gbc, | ||
210 | APVEntropyState *restrict state) | ||
211 | { | ||
212 | 13540 | const APVVLCLUT *lut = state->decode_lut; | |
213 | int scan_pos; | ||
214 | 13540 | 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 | 13540 | abs_diff = apv_read_vlc(gbc, k_dc, lut); | |
225 | |||
226 |
2/2✓ Branch 0 taken 12683 times.
✓ Branch 1 taken 857 times.
|
13540 | if (abs_diff) { |
227 | 12683 | sign = get_bits1(gbc); | |
228 |
2/2✓ Branch 0 taken 6446 times.
✓ Branch 1 taken 6237 times.
|
12683 | if (sign) |
229 | 6446 | dc_coeff = state->prev_dc - abs_diff; | |
230 | else | ||
231 | 6237 | dc_coeff = state->prev_dc + abs_diff; | |
232 | } else { | ||
233 | 857 | dc_coeff = state->prev_dc; | |
234 | } | ||
235 | |||
236 | |||
237 |
2/4✓ Branch 0 taken 13540 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 13540 times.
|
13540 | 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 | 13540 | coeff[0] = dc_coeff; | |
246 | |||
247 | 13540 | state->prev_dc = dc_coeff; | |
248 | 13540 | 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 | 13540 | k_level = state->prev_k_level; | |
265 | { | ||
266 | 13540 | next_bits = show_bits(gbc, 18); | |
267 | 13540 | lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS); | |
268 | |||
269 | 13540 | ent = &lut->run_first_lut[0][k_level][lut_bits]; | |
270 | |||
271 |
2/2✓ Branch 0 taken 667 times.
✓ Branch 1 taken 12873 times.
|
13540 | 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 | 667 | bits = next_bits & 0xffff; | |
279 | // Determine code length. | ||
280 | 667 | leading_zeroes = 15 - av_log2(bits); | |
281 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 667 times.
|
667 | 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 | 667 | low_bit_count = leading_zeroes; | |
290 | 667 | low_bit_shift = 16 - (1 + 2 * leading_zeroes); | |
291 | 667 | low_bits = (bits >> low_bit_shift) & ((1 << low_bit_count) - 1); | |
292 | // Construct run code. | ||
293 | 667 | run = 2 + ((1 << leading_zeroes) - 1) + low_bits; | |
294 | // Skip over the bits just used. | ||
295 | 667 | skip_bits(gbc, 2 + leading_zeroes + 1 + low_bit_count); | |
296 | |||
297 | 667 | scan_pos = run + 1; | |
298 |
2/2✓ Branch 0 taken 656 times.
✓ Branch 1 taken 11 times.
|
667 | if (scan_pos >= 64) |
299 | 656 | goto end_of_block; | |
300 | 11 | k_run = FFMIN(run >> 2, 2); | |
301 | 11 | 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 | 12873 | scan_pos = ent->run[0] + 1; | |
308 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12873 times.
|
12873 | if (scan_pos >= 64) { |
309 | ✗ | skip_bits(gbc, ent->offset[0]); | |
310 | ✗ | goto end_of_block; | |
311 | } | ||
312 |
2/2✓ Branch 0 taken 10614 times.
✓ Branch 1 taken 2259 times.
|
12873 | if (ent->count > 1) { |
313 | 10614 | coeff[ff_zigzag_direct[scan_pos]] = ent->level[0]; | |
314 | 10614 | ++scan_pos; | |
315 | 10614 | state->prev_k_level = ent->k_level_0; | |
316 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10614 times.
|
10614 | if (scan_pos >= 64) { |
317 | ✗ | skip_bits(gbc, ent->offset[1]); | |
318 | ✗ | goto end_of_block; | |
319 | } | ||
320 | } | ||
321 |
2/2✓ Branch 0 taken 8277 times.
✓ Branch 1 taken 4596 times.
|
12873 | if (ent->count > 2) { |
322 | 8277 | scan_pos += ent->run[1]; | |
323 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8277 times.
|
8277 | if (scan_pos >= 64) { |
324 | ✗ | skip_bits(gbc, ent->offset[2]); | |
325 | ✗ | goto end_of_block; | |
326 | } | ||
327 | } | ||
328 |
2/2✓ Branch 0 taken 1833 times.
✓ Branch 1 taken 11040 times.
|
12873 | if (ent->count > 3) { |
329 | 1833 | coeff[ff_zigzag_direct[scan_pos]] = ent->level[1]; | |
330 | 1833 | ++scan_pos; | |
331 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1833 times.
|
1833 | if (scan_pos >= 64) { |
332 | ✗ | skip_bits(gbc, ent->offset[3]); | |
333 | ✗ | goto end_of_block; | |
334 | } | ||
335 | } | ||
336 | 12873 | skip_bits(gbc, ent->offset[3]); | |
337 | 12873 | k_run = ent->k_run; | |
338 | 12873 | k_level = ent->k_level_1; | |
339 |
2/2✓ Branch 0 taken 2259 times.
✓ Branch 1 taken 10614 times.
|
12873 | if (ent->count == 1) |
340 | 2259 | goto first_level; | |
341 |
2/2✓ Branch 0 taken 6444 times.
✓ Branch 1 taken 4170 times.
|
10614 | else if (ent->count & 1) |
342 | 6444 | goto next_is_level; | |
343 | else | ||
344 | 4170 | goto next_is_run; | |
345 | } | ||
346 | } | ||
347 | |||
348 | 2270 | first_level: { | |
349 | 2270 | next_bits = show_bits(gbc, 18); | |
350 | 2270 | lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS); | |
351 | |||
352 | 2270 | ent = &lut->level_first_lut[k_run][k_level][lut_bits]; | |
353 | |||
354 |
2/2✓ Branch 0 taken 1602 times.
✓ Branch 1 taken 668 times.
|
2270 | 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 | 1602 | bits = next_bits & 0xffff; | |
362 | // Determine code length. | ||
363 | 1602 | leading_zeroes = 15 - av_log2(bits); | |
364 | // Skip the prefix and length bits. | ||
365 | 1602 | 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 | 3204 | abs_level = (2 << k_level) + | |
369 | 3204 | ((1 << leading_zeroes) - 1) * (1 << k_level) + | |
370 | 1602 | get_bits(gbc, leading_zeroes + k_level) + 1; | |
371 | |||
372 | 1602 | sign = get_bits(gbc, 1); | |
373 |
2/2✓ Branch 0 taken 756 times.
✓ Branch 1 taken 846 times.
|
1602 | if (sign) |
374 | 756 | level = -abs_level; | |
375 | else | ||
376 | 846 | 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 1602 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1602 times.
|
1602 | 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 | 1602 | coeff[ff_zigzag_direct[scan_pos]] = level; | |
388 | 1602 | ++scan_pos; | |
389 | 1602 | k_level = FFMIN(abs_level >> 2, 4); | |
390 | 1602 | state->prev_k_level = k_level; | |
391 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1602 times.
|
1602 | if (scan_pos >= 64) |
392 | ✗ | goto end_of_block; | |
393 | 1602 | goto next_is_run; | |
394 | |||
395 | } else { | ||
396 | // One or more short codes. | ||
397 | |||
398 | 668 | coeff[ff_zigzag_direct[scan_pos]] = ent->level[0]; | |
399 | 668 | ++scan_pos; | |
400 | 668 | state->prev_k_level = ent->k_level_0; | |
401 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 668 times.
|
668 | if (scan_pos >= 64) { |
402 | ✗ | skip_bits(gbc, ent->offset[0]); | |
403 | ✗ | goto end_of_block; | |
404 | } | ||
405 |
2/2✓ Branch 0 taken 78 times.
✓ Branch 1 taken 590 times.
|
668 | if (ent->count > 1) { |
406 | 78 | scan_pos += ent->run[0]; | |
407 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 78 times.
|
78 | if (scan_pos >= 64) { |
408 | ✗ | skip_bits(gbc, ent->offset[1]); | |
409 | ✗ | goto end_of_block; | |
410 | } | ||
411 | } | ||
412 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 653 times.
|
668 | if (ent->count > 2) { |
413 | 15 | coeff[ff_zigzag_direct[scan_pos]] = ent->level[1]; | |
414 | 15 | ++scan_pos; | |
415 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
|
15 | 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 667 times.
|
668 | 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 | 668 | skip_bits(gbc, ent->offset[3]); | |
428 | 668 | k_run = ent->k_run; | |
429 | 668 | k_level = ent->k_level_1; | |
430 |
2/2✓ Branch 0 taken 604 times.
✓ Branch 1 taken 64 times.
|
668 | if (ent->count & 1) |
431 | 604 | goto next_is_run; | |
432 | else | ||
433 | 64 | goto next_is_level; | |
434 | } | ||
435 | } | ||
436 | |||
437 | 51555 | next_is_run: { | |
438 | 96984 | next_bits = show_bits(gbc, 18); | |
439 | 96984 | lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS); | |
440 | |||
441 | 96984 | ent = &lut->run_first_lut[k_run][k_level][lut_bits]; | |
442 | |||
443 |
2/2✓ Branch 0 taken 3818 times.
✓ Branch 1 taken 93166 times.
|
96984 | 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 | 3818 | bits = next_bits & 0xffff; | |
451 | // Determine code length. | ||
452 | 3818 | leading_zeroes = 15 - av_log2(bits); | |
453 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3818 times.
|
3818 | 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 | 3818 | low_bit_count = leading_zeroes + k_run; | |
462 | 3818 | low_bit_shift = 16 - (1 + 2 * leading_zeroes + k_run); | |
463 | 3818 | low_bits = (bits >> low_bit_shift) & ((1 << low_bit_count) - 1); | |
464 | // Construct run code. | ||
465 | 3818 | run = (2 << k_run) + | |
466 | 3818 | ((1 << leading_zeroes) - 1) * (1 << k_run) + | |
467 | low_bits; | ||
468 | // Skip over the bits just used. | ||
469 | 3818 | skip_bits(gbc, 2 + leading_zeroes + 1 + low_bit_count); | |
470 | |||
471 | 3818 | scan_pos += run; | |
472 |
2/2✓ Branch 0 taken 3557 times.
✓ Branch 1 taken 261 times.
|
3818 | if (scan_pos >= 64) |
473 | 3557 | goto end_of_block; | |
474 | 261 | k_run = FFMIN(run >> 2, 2); | |
475 | 261 | goto next_is_level; | |
476 | |||
477 | } else { | ||
478 | // One or more short codes. | ||
479 | |||
480 | 93166 | scan_pos += ent->run[0]; | |
481 |
2/2✓ Branch 0 taken 3082 times.
✓ Branch 1 taken 90084 times.
|
93166 | if (scan_pos >= 64) { |
482 | 3082 | skip_bits(gbc, ent->offset[0]); | |
483 | 3082 | goto end_of_block; | |
484 | } | ||
485 |
2/2✓ Branch 0 taken 83545 times.
✓ Branch 1 taken 6539 times.
|
90084 | if (ent->count > 1) { |
486 | 83545 | coeff[ff_zigzag_direct[scan_pos]] = ent->level[0]; | |
487 | 83545 | ++scan_pos; | |
488 |
2/2✓ Branch 0 taken 830 times.
✓ Branch 1 taken 82715 times.
|
83545 | if (scan_pos >= 64) { |
489 | 830 | skip_bits(gbc, ent->offset[1]); | |
490 | 830 | goto end_of_block; | |
491 | } | ||
492 | } | ||
493 |
2/2✓ Branch 0 taken 69849 times.
✓ Branch 1 taken 19405 times.
|
89254 | if (ent->count > 2) { |
494 | 69849 | scan_pos += ent->run[1]; | |
495 |
2/2✓ Branch 0 taken 638 times.
✓ Branch 1 taken 69211 times.
|
69849 | if (scan_pos >= 64) { |
496 | 638 | skip_bits(gbc, ent->offset[2]); | |
497 | 638 | goto end_of_block; | |
498 | } | ||
499 | } | ||
500 |
2/2✓ Branch 0 taken 33124 times.
✓ Branch 1 taken 55492 times.
|
88616 | if (ent->count > 3) { |
501 | 33124 | coeff[ff_zigzag_direct[scan_pos]] = ent->level[1]; | |
502 | 33124 | ++scan_pos; | |
503 |
2/2✓ Branch 0 taken 561 times.
✓ Branch 1 taken 32563 times.
|
33124 | if (scan_pos >= 64) { |
504 | 561 | skip_bits(gbc, ent->offset[3]); | |
505 | 561 | goto end_of_block; | |
506 | } | ||
507 | } | ||
508 | 88055 | skip_bits(gbc, ent->offset[3]); | |
509 | 88055 | k_run = ent->k_run; | |
510 | 88055 | k_level = ent->k_level_1; | |
511 |
2/2✓ Branch 0 taken 42626 times.
✓ Branch 1 taken 45429 times.
|
88055 | if (ent->count & 1) |
512 | 42626 | goto next_is_level; | |
513 | else | ||
514 | 45429 | goto next_is_run; | |
515 | } | ||
516 | } | ||
517 | |||
518 | 49395 | next_is_level: { | |
519 | 204152 | next_bits = show_bits(gbc, 18); | |
520 | 204152 | lut_bits = next_bits >> (18 - APV_VLC_LUT_BITS); | |
521 | |||
522 | 204152 | ent = &lut->level_first_lut[k_run][k_level][lut_bits]; | |
523 | |||
524 |
2/2✓ Branch 0 taken 9896 times.
✓ Branch 1 taken 194256 times.
|
204152 | 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 | 9896 | bits = next_bits & 0xffff; | |
532 | // Determine code length. | ||
533 | 9896 | leading_zeroes = 15 - av_log2(bits); | |
534 | // Skip the prefix and length bits. | ||
535 | 9896 | 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 | 19792 | abs_level = (2 << k_level) + | |
539 | 19792 | ((1 << leading_zeroes) - 1) * (1 << k_level) + | |
540 | 9896 | get_bits(gbc, leading_zeroes + k_level) + 1; | |
541 | |||
542 | 9896 | sign = get_bits(gbc, 1); | |
543 |
2/2✓ Branch 0 taken 4947 times.
✓ Branch 1 taken 4949 times.
|
9896 | if (sign) |
544 | 4947 | level = -abs_level; | |
545 | else | ||
546 | 4949 | 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 9896 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9896 times.
|
9896 | 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 | 9896 | coeff[ff_zigzag_direct[scan_pos]] = level; | |
558 | 9896 | ++scan_pos; | |
559 | 9896 | k_level = FFMIN(abs_level >> 2, 4); | |
560 |
2/2✓ Branch 0 taken 25 times.
✓ Branch 1 taken 9871 times.
|
9896 | if (scan_pos >= 64) |
561 | 25 | goto end_of_block; | |
562 | 9871 | goto next_is_run; | |
563 | |||
564 | } else { | ||
565 | // One or more short codes. | ||
566 | |||
567 | 194256 | coeff[ff_zigzag_direct[scan_pos]] = ent->level[0]; | |
568 | 194256 | ++scan_pos; | |
569 |
2/2✓ Branch 0 taken 1081 times.
✓ Branch 1 taken 193175 times.
|
194256 | if (scan_pos >= 64) { |
570 | 1081 | skip_bits(gbc, ent->offset[0]); | |
571 | 1081 | goto end_of_block; | |
572 | } | ||
573 |
2/2✓ Branch 0 taken 184306 times.
✓ Branch 1 taken 8869 times.
|
193175 | if (ent->count > 1) { |
574 | 184306 | scan_pos += ent->run[0]; | |
575 |
2/2✓ Branch 0 taken 1500 times.
✓ Branch 1 taken 182806 times.
|
184306 | if (scan_pos >= 64) { |
576 | 1500 | skip_bits(gbc, ent->offset[1]); | |
577 | 1500 | goto end_of_block; | |
578 | } | ||
579 | } | ||
580 |
2/2✓ Branch 0 taken 91153 times.
✓ Branch 1 taken 100522 times.
|
191675 | if (ent->count > 2) { |
581 | 91153 | coeff[ff_zigzag_direct[scan_pos]] = ent->level[1]; | |
582 | 91153 | ++scan_pos; | |
583 |
2/2✓ Branch 0 taken 1054 times.
✓ Branch 1 taken 90099 times.
|
91153 | if (scan_pos >= 64) { |
584 | 1054 | skip_bits(gbc, ent->offset[2]); | |
585 | 1054 | goto end_of_block; | |
586 | } | ||
587 | } | ||
588 |
2/2✓ Branch 0 taken 63660 times.
✓ Branch 1 taken 126961 times.
|
190621 | if (ent->count > 3) { |
589 | 63660 | scan_pos += ent->run[1]; | |
590 |
2/2✓ Branch 0 taken 556 times.
✓ Branch 1 taken 63104 times.
|
63660 | if (scan_pos >= 64) { |
591 | 556 | skip_bits(gbc, ent->offset[3]); | |
592 | 556 | goto end_of_block; | |
593 | } | ||
594 | } | ||
595 | 190065 | skip_bits(gbc, ent->offset[3]); | |
596 | 190065 | k_run = ent->k_run; | |
597 | 190065 | k_level = ent->k_level_1; | |
598 |
2/2✓ Branch 0 taken 35308 times.
✓ Branch 1 taken 154757 times.
|
190065 | if (ent->count & 1) |
599 | 35308 | goto next_is_run; | |
600 | else | ||
601 | 154757 | goto next_is_level; | |
602 | } | ||
603 | } | ||
604 | |||
605 | 13540 | end_of_block: { | |
606 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13540 times.
|
13540 | 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 | 13540 | return 0; | |
613 | } | ||
614 | } | ||
615 |