FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/bitstream_template.h
Date: 2023-06-04 16:45:34
Exec Total Coverage
Lines: 142 156 91.0%
Functions: 48 48 100.0%
Branches: 61 90 67.8%
Line Branch Exec Source
1 /*
2 * Copyright (c) 2016 Alexandra Hájková
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #ifdef BITSTREAM_TEMPLATE_LE
22 # define BS_SUFFIX_LOWER _le
23 # define BS_SUFFIX_UPPER LE
24 #else
25 # define BS_SUFFIX_LOWER _be
26 # define BS_SUFFIX_UPPER BE
27 #endif
28
29 #define BS_JOIN(x, y, z) x ## y ## z
30 #define BS_JOIN3(x, y, z) BS_JOIN(x, y, z)
31 #define BS_FUNC(x) BS_JOIN3(bits_, x, BS_SUFFIX_LOWER)
32
33 #define BSCTX BS_JOIN3(Bitstream, Context, BS_SUFFIX_UPPER)
34
35 typedef struct BSCTX {
36 uint64_t bits; // stores bits read from the buffer
37 const uint8_t *buffer, *buffer_end;
38 const uint8_t *ptr; // pointer to the position inside a buffer
39 unsigned bits_valid; // number of bits left in bits field
40 unsigned size_in_bits;
41 } BSCTX;
42
43 /**
44 * @return
45 * - 0 on successful refill
46 * - a negative number when bitstream end is hit
47 *
48 * Always succeeds when UNCHECKED_BITSTREAM_READER is enabled.
49 */
50 22018 static inline int BS_FUNC(priv_refill_64)(BSCTX *bc)
51 {
52 #if !UNCHECKED_BITSTREAM_READER
53
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 20163 times.
 20169 if (bc->ptr >= bc->buffer_end)
54 6 return -1;
55 #endif
56
57 #ifdef BITSTREAM_TEMPLATE_LE
58 19776 bc->bits = AV_RL64(bc->ptr);
59 #else
60 2236 bc->bits = AV_RB64(bc->ptr);
61 #endif
62 22012 bc->ptr += 8;
63 22012 bc->bits_valid = 64;
64
65 22012 return 0;
66 }
67
68 /**
69 * @return
70 * - 0 on successful refill
71 * - a negative number when bitstream end is hit
72 *
73 * Always succeeds when UNCHECKED_BITSTREAM_READER is enabled.
74 */
75 5550993 static inline int BS_FUNC(priv_refill_32)(BSCTX *bc)
76 {
77 #if !UNCHECKED_BITSTREAM_READER
78
2/2
✓ Branch 0 taken 274 times.
✓ Branch 1 taken 409779 times.
 410053 if (bc->ptr >= bc->buffer_end)
79 274 return -1;
80 #endif
81
82 #ifdef BITSTREAM_TEMPLATE_LE
83 217957 bc->bits |= (uint64_t)AV_RL32(bc->ptr) << bc->bits_valid;
84 #else
85 5332762 bc->bits |= (uint64_t)AV_RB32(bc->ptr) << (32 - bc->bits_valid);
86 #endif
87 5550719 bc->ptr += 4;
88 5550719 bc->bits_valid += 32;
89
90 5550719 return 0;
91 }
92
93 /**
94 * Initialize BitstreamContext.
95 * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
96 * larger than the actual read bits because some optimized bitstream
97 * readers read 32 or 64 bits at once and could read over the end
98 * @param bit_size the size of the buffer in bits
99 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
100 */
101 2355 static inline int BS_FUNC(init)(BSCTX *bc, const uint8_t *buffer,
102 unsigned int bit_size)
103 {
104 unsigned int buffer_size;
105
106
2/4
✓ Branch 0 taken 1639 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1639 times.
 2355 if (bit_size > INT_MAX - 7 || !buffer) {
107 ✗ bc->buffer = NULL;
108 ✗ bc->ptr = NULL;
109 ✗ bc->bits_valid = 0;
110 ✗ return AVERROR_INVALIDDATA;
111 }
112
113 2355 buffer_size = (bit_size + 7) >> 3;
114
115 2355 bc->buffer = buffer;
116 2355 bc->buffer_end = buffer + buffer_size;
117 2355 bc->ptr = bc->buffer;
118 2355 bc->size_in_bits = bit_size;
119 2355 bc->bits_valid = 0;
120 2355 bc->bits = 0;
121
122 2355 BS_FUNC(priv_refill_64)(bc);
123
124 2355 return 0;
125 }
126
127 /**
128 * Initialize BitstreamContext.
129 * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
130 * larger than the actual read bits because some optimized bitstream
131 * readers read 32 or 64 bits at once and could read over the end
132 * @param byte_size the size of the buffer in bytes
133 * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow
134 */
135 923 static inline int BS_FUNC(init8)(BSCTX *bc, const uint8_t *buffer,
136 unsigned int byte_size)
137 {
138
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 923 times.
 923 if (byte_size > INT_MAX / 8)
139 ✗ return AVERROR_INVALIDDATA;
140 923 return BS_FUNC(init)(bc, buffer, byte_size * 8);
141 }
142
143 /**
144 * Return number of bits already read.
145 */
146 463 static inline int BS_FUNC(tell)(const BSCTX *bc)
147 {
148 463 return (bc->ptr - bc->buffer) * 8 - bc->bits_valid;
149 }
150
151 /**
152 * Return buffer size in bits.
153 */
154 static inline int BS_FUNC(size)(const BSCTX *bc)
155 {
156 return bc->size_in_bits;
157 }
158
159 /**
160 * Return the number of the bits left in a buffer.
161 */
162 31369836 static inline int BS_FUNC(left)(const BSCTX *bc)
163 {
164 31369836 return (bc->buffer - bc->ptr) * 8 + bc->size_in_bits + bc->bits_valid;
165 }
166
167 103754297 static inline uint64_t BS_FUNC(priv_val_show)(BSCTX *bc, unsigned int n)
168 {
169
2/4
✓ Branch 0 taken 265 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 265 times.
 265 av_assert2(n > 0 && n <= 64);
170
171 #ifdef BITSTREAM_TEMPLATE_LE
172 1561123 return bc->bits & (UINT64_MAX >> (64 - n));
173 #else
174 102193174 return bc->bits >> (64 - n);
175 #endif
176 }
177
178 103754335 static inline void BS_FUNC(priv_skip_remaining)(BSCTX *bc, unsigned int n)
179 {
180 #ifdef BITSTREAM_TEMPLATE_LE
181 1561207 bc->bits >>= n;
182 #else
183 102193128 bc->bits <<= n;
184 #endif
185 103754335 bc->bits_valid -= n;
186 103754335 }
187
188 1561150 static inline uint64_t BS_FUNC(priv_val_get)(BSCTX *bc, unsigned int n)
189 {
190 uint64_t ret;
191
192
2/4
✓ Branch 0 taken 162 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 162 times.
 162 av_assert2(n > 0 && n < 64);
193
194 1561150 ret = BS_FUNC(priv_val_show)(bc, n);
195 1561150 BS_FUNC(priv_skip_remaining)(bc, n);
196
197 1561150 return ret;
198 }
199
200 /**
201 * Return one bit from the buffer.
202 */
203 686445 static inline unsigned int BS_FUNC(read_bit)(BSCTX *bc)
204 {
205
3/4
✓ Branch 0 taken 19462 times.
✓ Branch 1 taken 666983 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 19462 times.
 686445 if (!bc->bits_valid && BS_FUNC(priv_refill_64)(bc) < 0)
206 ✗ return 0;
207
208 686445 return BS_FUNC(priv_val_get)(bc, 1);
209 }
210
211 /**
212 * Return n bits from the buffer, n has to be in the 1-32 range.
213 * May be faster than bits_read() when n is not a compile-time constant and is
214 * known to be non-zero;
215 */
216 874621 static inline uint32_t BS_FUNC(read_nz)(BSCTX *bc, unsigned int n)
217 {
218
2/4
✓ Branch 0 taken 107 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 107 times.
 107 av_assert2(n > 0 && n <= 32);
219
220
2/2
✓ Branch 0 taken 217939 times.
✓ Branch 1 taken 656682 times.
 874621 if (n > bc->bits_valid) {
221
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 217939 times.
 217939 if (BS_FUNC(priv_refill_32)(bc) < 0)
222 ✗ bc->bits_valid = n;
223 }
224
225 874621 return BS_FUNC(priv_val_get)(bc, n);
226 }
227
228 /**
229 * Return n bits from the buffer, n has to be in the 0-32 range.
230 */
231 860024 static inline uint32_t BS_FUNC(read)(BSCTX *bc, unsigned int n)
232 {
233
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 43 times.
 43 av_assert2(n <= 32);
234
235
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 860023 times.
 860024 if (!n)
236 1 return 0;
237
238 860023 return BS_FUNC(read_nz)(bc, n);
239 }
240
241 /**
242 * Return n bits from the buffer, n has to be in the 0-63 range.
243 */
244 51 static inline uint64_t BS_FUNC(read_63)(BSCTX *bc, unsigned int n)
245 {
246 51 uint64_t ret = 0;
247 51 unsigned left = 0;
248
249
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.
 28 av_assert2(n <= 63);
250
251
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 50 times.
 51 if (!n)
252 1 return 0;
253
254
2/2
✓ Branch 0 taken 34 times.
✓ Branch 1 taken 16 times.
 50 if (n > bc->bits_valid) {
255 34 left = bc->bits_valid;
256 34 n -= left;
257
258
1/2
✓ Branch 0 taken 34 times.
✗ Branch 1 not taken.
 34 if (left)
259 34 ret = BS_FUNC(priv_val_get)(bc, left);
260
261
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 34 times.
 34 if (BS_FUNC(priv_refill_64)(bc) < 0)
262 ✗ bc->bits_valid = n;
263
264 }
265
266 #ifdef BITSTREAM_TEMPLATE_LE
267 36 ret = BS_FUNC(priv_val_get)(bc, n) << left | ret;
268 #else
269 14 ret = BS_FUNC(priv_val_get)(bc, n) | ret << n;
270 #endif
271
272 50 return ret;
273 }
274
275 /**
276 * Return n bits from the buffer, n has to be in the 0-64 range.
277 */
278 41 static inline uint64_t BS_FUNC(read_64)(BSCTX *bc, unsigned int n)
279 {
280
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
 18 av_assert2(n <= 64);
281
282
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.
 41 if (n == 64) {
283 ✗ uint64_t ret = BS_FUNC(read_63)(bc, 63);
284 #ifdef BITSTREAM_TEMPLATE_LE
285 ✗ return ret | ((uint64_t)BS_FUNC(read_bit)(bc) << 63);
286 #else
287 ✗ return (ret << 1) | (uint64_t)BS_FUNC(read_bit)(bc);
288 #endif
289 }
290 41 return BS_FUNC(read_63)(bc, n);
291 }
292
293 /**
294 * Return n bits from the buffer as a signed integer, n has to be in the 1-32
295 * range. May be faster than bits_read_signed() when n is not a compile-time
296 * constant and is known to be non-zero;
297 */
298 10411 static inline int32_t BS_FUNC(read_signed_nz)(BSCTX *bc, unsigned int n)
299 {
300
2/4
✓ Branch 0 taken 51 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 51 times.
 51 av_assert2(n > 0 && n <= 32);
301 10411 return sign_extend(BS_FUNC(read_nz)(bc, n), n);
302 }
303
304 /**
305 * Return n bits from the buffer as a signed integer.
306 * n has to be in the 0-32 range.
307 */
308 35 static inline int32_t BS_FUNC(read_signed)(BSCTX *bc, unsigned int n)
309 {
310
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 35 times.
 35 av_assert2(n <= 32);
311
312
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 33 times.
 35 if (!n)
313 2 return 0;
314
315 33 return BS_FUNC(read_signed_nz)(bc, n);
316 }
317
318 /**
319 * Return n bits from the buffer but do not change the buffer state.
320 * n has to be in the 1-32 range. May
321 */
322 66850220 static inline uint32_t BS_FUNC(peek_nz)(BSCTX *bc, unsigned int n)
323 {
324
2/4
✓ Branch 0 taken 103 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 103 times.
 103 av_assert2(n > 0 && n <= 32);
325
326
2/2
✓ Branch 0 taken 3984215 times.
✓ Branch 1 taken 62866005 times.
 66850220 if (n > bc->bits_valid)
327 3984215 BS_FUNC(priv_refill_32)(bc);
328
329 66850220 return BS_FUNC(priv_val_show)(bc, n);
330 }
331
332 /**
333 * Return n bits from the buffer but do not change the buffer state.
334 * n has to be in the 0-32 range.
335 */
336 66850179 static inline uint32_t BS_FUNC(peek)(BSCTX *bc, unsigned int n)
337 {
338
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
 62 av_assert2(n <= 32);
339
340
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 66850171 times.
 66850179 if (!n)
341 8 return 0;
342
343 66850171 return BS_FUNC(peek_nz)(bc, n);
344 }
345
346 /**
347 * Return n bits from the buffer as a signed integer, do not change the buffer
348 * state. n has to be in the 1-32 range. May be faster than bits_peek_signed()
349 * when n is not a compile-time constant and is known to be non-zero;
350 */
351 35 static inline int BS_FUNC(peek_signed_nz)(BSCTX *bc, unsigned int n)
352 {
353
2/4
✓ Branch 0 taken 35 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 35 times.
 35 av_assert2(n > 0 && n <= 32);
354 35 return sign_extend(BS_FUNC(peek_nz)(bc, n), n);
355 }
356
357 /**
358 * Return n bits from the buffer as a signed integer,
359 * do not change the buffer state.
360 * n has to be in the 0-32 range.
361 */
362 19 static inline int BS_FUNC(peek_signed)(BSCTX *bc, unsigned int n)
363 {
364
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
 19 av_assert2(n <= 32);
365
366
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 17 times.
 19 if (!n)
367 2 return 0;
368
369 17 return BS_FUNC(peek_signed_nz)(bc, n);
370 }
371
372 /**
373 * Skip n bits in the buffer.
374 */
375 267 static inline void BS_FUNC(skip)(BSCTX *bc, unsigned int n)
376 {
377
2/2
✓ Branch 0 taken 100 times.
✓ Branch 1 taken 167 times.
 267 if (n < bc->bits_valid)
378 100 BS_FUNC(priv_skip_remaining)(bc, n);
379 else {
380 167 n -= bc->bits_valid;
381 167 bc->bits = 0;
382 167 bc->bits_valid = 0;
383
384
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 167 times.
 167 if (n >= 64) {
385 ✗ unsigned int skip = n / 8;
386
387 ✗ n -= skip * 8;
388 ✗ bc->ptr += skip;
389 }
390 167 BS_FUNC(priv_refill_64)(bc);
391
2/2
✓ Branch 0 taken 41 times.
✓ Branch 1 taken 126 times.
 167 if (n)
392 41 BS_FUNC(priv_skip_remaining)(bc, n);
393 }
394 267 }
395
396 /**
397 * Seek to the given bit position.
398 */
399 static inline void BS_FUNC(seek)(BSCTX *bc, unsigned pos)
400 {
401 bc->ptr = bc->buffer;
402 bc->bits = 0;
403 bc->bits_valid = 0;
404
405 BS_FUNC(skip)(bc, pos);
406 }
407
408 /**
409 * Skip bits to a byte boundary.
410 */
411 78 static inline const uint8_t *BS_FUNC(align)(BSCTX *bc)
412 {
413 78 unsigned int n = -BS_FUNC(tell)(bc) & 7;
414
2/2
✓ Branch 0 taken 67 times.
✓ Branch 1 taken 11 times.
 78 if (n)
415 67 BS_FUNC(skip)(bc, n);
416 78 return bc->buffer + (BS_FUNC(tell)(bc) >> 3);
417 }
418
419 /**
420 * Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
421 * If MSB not set it is negative.
422 * @param n length in bits
423 */
424 static inline int BS_FUNC(read_xbits)(BSCTX *bc, unsigned int n)
425 {
426 int32_t cache = BS_FUNC(peek)(bc, 32);
427 int sign = ~cache >> 31;
428 BS_FUNC(priv_skip_remaining)(bc, n);
429
430 return ((((uint32_t)(sign ^ cache)) >> (32 - n)) ^ sign) - sign;
431 }
432
433 /**
434 * Return decoded truncated unary code for the values 0, 1, 2.
435 */
436 static inline int BS_FUNC(decode012)(BSCTX *bc)
437 {
438 if (!BS_FUNC(read_bit)(bc))
439 return 0;
440 else
441 return BS_FUNC(read_bit)(bc) + 1;
442 }
443
444 /**
445 * Return decoded truncated unary code for the values 2, 1, 0.
446 */
447 static inline int BS_FUNC(decode210)(BSCTX *bc)
448 {
449 if (BS_FUNC(read_bit)(bc))
450 return 0;
451 else
452 return 2 - BS_FUNC(read_bit)(bc);
453 }
454
455 /* Read sign bit and flip the sign of the provided value accordingly. */
456 16 static inline int BS_FUNC(apply_sign)(BSCTX *bc, int val)
457 {
458 16 int sign = BS_FUNC(read_signed)(bc, 1);
459 16 return (val ^ sign) - sign;
460 }
461
462 static inline int BS_FUNC(skip_1stop_8data)(BSCTX *s)
463 {
464 if (BS_FUNC(left)(s) <= 0)
465 return AVERROR_INVALIDDATA;
466
467 while (BS_FUNC(read_bit)(s)) {
468 BS_FUNC(skip)(s, 8);
469 if (BS_FUNC(left)(s) <= 0)
470 return AVERROR_INVALIDDATA;
471 }
472
473 return 0;
474 }
475
476 /**
477 * Return the LUT element for the given bitstream configuration.
478 */
479 282167 static inline int BS_FUNC(priv_set_idx)(BSCTX *bc, int code, int *n,
480 int *nb_bits, const VLCElem *table)
481 {
482 unsigned idx;
483
484 282167 *nb_bits = -*n;
485 282167 idx = BS_FUNC(peek)(bc, *nb_bits) + code;
486 282167 *n = table[idx].len;
487
488 282167 return table[idx].sym;
489 }
490
491 /**
492 * Parse a vlc code.
493 * @param bits is the number of bits which will be read at once, must be
494 * identical to nb_bits in init_vlc()
495 * @param max_depth is the number of times bits bits must be read to completely
496 * read the longest vlc code
497 * = (max_vlc_length + bits - 1) / bits
498 * If the vlc code is invalid and max_depth=1, then no bits will be removed.
499 * If the vlc code is invalid and max_depth>1, then the number of bits removed
500 * is undefined.
501 */
502 66567950 static inline int BS_FUNC(read_vlc)(BSCTX *bc, const VLCElem *table,
503 int bits, int max_depth)
504 {
505 int nb_bits;
506 66567950 unsigned idx = BS_FUNC(peek)(bc, bits);
507 66567950 int code = table[idx].sym;
508 66567950 int n = table[idx].len;
509
510
3/4
✓ Branch 0 taken 66567950 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 282110 times.
✓ Branch 3 taken 66285840 times.
 66567950 if (max_depth > 1 && n < 0) {
511 282110 BS_FUNC(priv_skip_remaining)(bc, bits);
512 282110 code = BS_FUNC(priv_set_idx)(bc, code, &n, &nb_bits, table);
513
3/4
✓ Branch 0 taken 282110 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 57 times.
✓ Branch 3 taken 282053 times.
 282110 if (max_depth > 2 && n < 0) {
514 57 BS_FUNC(priv_skip_remaining)(bc, nb_bits);
515 57 code = BS_FUNC(priv_set_idx)(bc, code, &n, &nb_bits, table);
516 }
517 }
518 66567950 BS_FUNC(priv_skip_remaining)(bc, n);
519
520 66567950 return code;
521 }
522
523 #undef BSCTX
524 #undef BS_FUNC
525 #undef BS_JOIN3
526 #undef BS_JOIN
527 #undef BS_SUFFIX_UPPER
528 #undef BS_SUFFIX_LOWER
529