FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/bink.c
Date: 2025-11-10 16:28:23
Exec Total Coverage
Lines: 669 814 82.2%
Functions: 29 30 96.7%
Branches: 419 533 78.6%
Line Branch Exec Source
1 /*
2 * Bink video decoder
3 * Copyright (c) 2009 Konstantin Shishkov
4 * Copyright (C) 2011 Peter Ross <pross@xvid.org>
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 #include "libavutil/attributes.h"
24 #include "libavutil/imgutils.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/mem_internal.h"
27 #include "libavutil/thread.h"
28
29 #define BITSTREAM_READER_LE
30 #include "avcodec.h"
31 #include "binkdata.h"
32 #include "binkdsp.h"
33 #include "blockdsp.h"
34 #include "codec_internal.h"
35 #include "decode.h"
36 #include "get_bits.h"
37 #include "hpeldsp.h"
38
39 #define BINK_FLAG_ALPHA 0x00100000
40 #define BINK_FLAG_GRAY 0x00020000
41
42 static VLC bink_trees[16];
43
44 /**
45 * IDs for different data types used in old version of Bink video codec
46 */
47 enum OldSources {
48 BINKB_SRC_BLOCK_TYPES = 0, ///< 8x8 block types
49 BINKB_SRC_COLORS, ///< pixel values used for different block types
50 BINKB_SRC_PATTERN, ///< 8-bit values for 2-colour pattern fill
51 BINKB_SRC_X_OFF, ///< X components of motion value
52 BINKB_SRC_Y_OFF, ///< Y components of motion value
53 BINKB_SRC_INTRA_DC, ///< DC values for intrablocks with DCT
54 BINKB_SRC_INTER_DC, ///< DC values for interblocks with DCT
55 BINKB_SRC_INTRA_Q, ///< quantizer values for intrablocks with DCT
56 BINKB_SRC_INTER_Q, ///< quantizer values for interblocks with DCT
57 BINKB_SRC_INTER_COEFS, ///< number of coefficients for residue blocks
58
59 BINKB_NB_SRC
60 };
61
62 static const uint8_t binkb_bundle_sizes[BINKB_NB_SRC] = {
63 4, 8, 8, 5, 5, 11, 11, 4, 4, 7
64 };
65
66 static const uint8_t binkb_bundle_signed[BINKB_NB_SRC] = {
67 0, 0, 0, 1, 1, 0, 1, 0, 0, 0
68 };
69
70 static int32_t binkb_intra_quant[16][64];
71 static int32_t binkb_inter_quant[16][64];
72
73 /**
74 * IDs for different data types used in Bink video codec
75 */
76 enum Sources {
77 BINK_SRC_BLOCK_TYPES = 0, ///< 8x8 block types
78 BINK_SRC_SUB_BLOCK_TYPES, ///< 16x16 block types (a subset of 8x8 block types)
79 BINK_SRC_COLORS, ///< pixel values used for different block types
80 BINK_SRC_PATTERN, ///< 8-bit values for 2-colour pattern fill
81 BINK_SRC_X_OFF, ///< X components of motion value
82 BINK_SRC_Y_OFF, ///< Y components of motion value
83 BINK_SRC_INTRA_DC, ///< DC values for intrablocks with DCT
84 BINK_SRC_INTER_DC, ///< DC values for interblocks with DCT
85 BINK_SRC_RUN, ///< run lengths for special fill block
86
87 BINK_NB_SRC
88 };
89
90 /**
91 * data needed to decode 4-bit Huffman-coded value
92 */
93 typedef struct Tree {
94 int vlc_num; ///< tree number (in bink_trees[])
95 uint8_t syms[16]; ///< leaf value to symbol mapping
96 } Tree;
97
98 #define GET_HUFF(gb, tree) (tree).syms[get_vlc2(gb, bink_trees[(tree).vlc_num].table,\
99 bink_trees[(tree).vlc_num].bits, 1)]
100
101 /**
102 * data structure used for decoding single Bink data type
103 */
104 typedef struct Bundle {
105 int len; ///< length of number of entries to decode (in bits)
106 Tree tree; ///< Huffman tree-related data
107 uint8_t *data; ///< buffer for decoded symbols
108 uint8_t *data_end; ///< buffer end
109 uint8_t *cur_dec; ///< pointer to the not yet decoded part of the buffer
110 uint8_t *cur_ptr; ///< pointer to the data that is not read from buffer yet
111 } Bundle;
112
113 /*
114 * Decoder context
115 */
116 typedef struct BinkContext {
117 AVCodecContext *avctx;
118 BlockDSPContext bdsp;
119 op_pixels_func put_pixels_tab;
120 BinkDSPContext binkdsp;
121 AVFrame *last;
122 int version; ///< internal Bink file version
123 int has_alpha;
124 int swap_planes;
125 unsigned frame_num;
126
127 Bundle bundle[BINKB_NB_SRC]; ///< bundles for decoding all data types
128 Tree col_high[16]; ///< trees for decoding high nibble in "colours" data type
129 int col_lastval; ///< value of last decoded high nibble in "colours" data type
130 } BinkContext;
131
132 /**
133 * Bink video block types
134 */
135 enum BlockTypes {
136 SKIP_BLOCK = 0, ///< skipped block
137 SCALED_BLOCK, ///< block has size 16x16
138 MOTION_BLOCK, ///< block is copied from previous frame with some offset
139 RUN_BLOCK, ///< block is composed from runs of colours with custom scan order
140 RESIDUE_BLOCK, ///< motion block with some difference added
141 INTRA_BLOCK, ///< intra DCT block
142 FILL_BLOCK, ///< block is filled with single colour
143 INTER_BLOCK, ///< motion block with DCT applied to the difference
144 PATTERN_BLOCK, ///< block is filled with two colours following custom pattern
145 RAW_BLOCK, ///< uncoded 8x8 block
146 };
147
148 /**
149 * Initialize length in all bundles.
150 *
151 * @param c decoder context
152 * @param width plane width
153 * @param bw plane width in 8x8 blocks
154 */
155 153 static void init_lengths(BinkContext *c, int width, int bw)
156 {
157 153 width = FFALIGN(width, 8);
158
159 153 c->bundle[BINK_SRC_BLOCK_TYPES].len = av_log2((width >> 3) + 511) + 1;
160
161 153 c->bundle[BINK_SRC_SUB_BLOCK_TYPES].len = av_log2((width >> 4) + 511) + 1;
162
163 153 c->bundle[BINK_SRC_COLORS].len = av_log2(bw*64 + 511) + 1;
164
165 153 c->bundle[BINK_SRC_INTRA_DC].len =
166 153 c->bundle[BINK_SRC_INTER_DC].len =
167 153 c->bundle[BINK_SRC_X_OFF].len =
168 153 c->bundle[BINK_SRC_Y_OFF].len = av_log2((width >> 3) + 511) + 1;
169
170 153 c->bundle[BINK_SRC_PATTERN].len = av_log2((bw << 3) + 511) + 1;
171
172 153 c->bundle[BINK_SRC_RUN].len = av_log2(bw*48 + 511) + 1;
173 153 }
174
175 /**
176 * Allocate memory for bundles.
177 *
178 * @param c decoder context
179 */
180 9 static av_cold int init_bundles(BinkContext *c)
181 {
182 int bw, bh, blocks;
183 uint8_t *tmp;
184 int i;
185
186 9 bw = (c->avctx->width + 7) >> 3;
187 9 bh = (c->avctx->height + 7) >> 3;
188 9 blocks = bw * bh;
189
190 9 tmp = av_calloc(blocks, 64 * BINKB_NB_SRC);
191
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (!tmp)
192 ✗ return AVERROR(ENOMEM);
193
2/2
✓ Branch 0 taken 90 times.
✓ Branch 1 taken 9 times.
 99 for (i = 0; i < BINKB_NB_SRC; i++) {
194 90 c->bundle[i].data = tmp;
195 90 tmp += blocks * 64;
196 90 c->bundle[i].data_end = tmp;
197 }
198
199 9 return 0;
200 }
201
202 /**
203 * Free memory used by bundles.
204 *
205 * @param c decoder context
206 */
207 9 static av_cold void free_bundles(BinkContext *c)
208 {
209 9 av_freep(&c->bundle[0].data);
210 9 }
211
212 /**
213 * Merge two consequent lists of equal size depending on bits read.
214 *
215 * @param gb context for reading bits
216 * @param dst buffer where merged list will be written to
217 * @param src pointer to the head of the first list (the second lists starts at src+size)
218 * @param size input lists size
219 */
220 1600 static void merge(GetBitContext *gb, uint8_t *dst, uint8_t *src, int size)
221 {
222 1600 uint8_t *src2 = src + size;
223 1600 int size2 = size;
224
225 do {
226
2/2
✓ Branch 1 taken 2289 times.
✓ Branch 2 taken 1472 times.
 3761 if (!get_bits1(gb)) {
227 2289 *dst++ = *src++;
228 2289 size--;
229 } else {
230 1472 *dst++ = *src2++;
231 1472 size2--;
232 }
233
4/4
✓ Branch 0 taken 2557 times.
✓ Branch 1 taken 1204 times.
✓ Branch 2 taken 2161 times.
✓ Branch 3 taken 396 times.
 3761 } while (size && size2);
234
235
2/2
✓ Branch 0 taken 951 times.
✓ Branch 1 taken 1600 times.
 2551 while (size--)
236 951 *dst++ = *src++;
237
2/2
✓ Branch 0 taken 1768 times.
✓ Branch 1 taken 1600 times.
 3368 while (size2--)
238 1768 *dst++ = *src2++;
239 1600 }
240
241 /**
242 * Read information about Huffman tree used to decode data.
243 *
244 * @param gb context for reading bits
245 * @param tree pointer for storing tree data
246 */
247 3519 static int read_tree(GetBitContext *gb, Tree *tree)
248 {
249 3519 uint8_t tmp1[16] = { 0 }, tmp2[16], *in = tmp1, *out = tmp2;
250 int i, t, len;
251
252
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3519 times.
 3519 if (get_bits_left(gb) < 4)
253 ✗ return AVERROR_INVALIDDATA;
254
255 3519 tree->vlc_num = get_bits(gb, 4);
256
2/2
✓ Branch 0 taken 1539 times.
✓ Branch 1 taken 1980 times.
 3519 if (!tree->vlc_num) {
257
2/2
✓ Branch 0 taken 24624 times.
✓ Branch 1 taken 1539 times.
 26163 for (i = 0; i < 16; i++)
258 24624 tree->syms[i] = i;
259 1539 return 0;
260 }
261
2/2
✓ Branch 1 taken 1871 times.
✓ Branch 2 taken 109 times.
 1980 if (get_bits1(gb)) {
262 1871 len = get_bits(gb, 3);
263
2/2
✓ Branch 0 taken 6542 times.
✓ Branch 1 taken 1871 times.
 8413 for (i = 0; i <= len; i++) {
264 6542 tree->syms[i] = get_bits(gb, 4);
265 6542 tmp1[tree->syms[i]] = 1;
266 }
267
4/4
✓ Branch 0 taken 29464 times.
✓ Branch 1 taken 1486 times.
✓ Branch 2 taken 29079 times.
✓ Branch 3 taken 385 times.
 30950 for (i = 0; i < 16 && len < 16 - 1; i++)
268
2/2
✓ Branch 0 taken 23394 times.
✓ Branch 1 taken 5685 times.
 29079 if (!tmp1[i])
269 23394 tree->syms[++len] = i;
270 } else {
271 109 len = get_bits(gb, 2);
272
2/2
✓ Branch 0 taken 1744 times.
✓ Branch 1 taken 109 times.
 1853 for (i = 0; i < 16; i++)
273 1744 in[i] = i;
274
2/2
✓ Branch 0 taken 405 times.
✓ Branch 1 taken 109 times.
 514 for (i = 0; i <= len; i++) {
275 405 int size = 1 << i;
276
2/2
✓ Branch 0 taken 1600 times.
✓ Branch 1 taken 405 times.
 2005 for (t = 0; t < 16; t += size << 1)
277 1600 merge(gb, out + t, in + t, size);
278 405 FFSWAP(uint8_t*, in, out);
279 }
280 109 memcpy(tree->syms, in, 16);
281 }
282 1980 return 0;
283 }
284
285 /**
286 * Prepare bundle for decoding data.
287 *
288 * @param gb context for reading bits
289 * @param c decoder context
290 * @param bundle_num number of the bundle to initialize
291 */
292 1377 static int read_bundle(GetBitContext *gb, BinkContext *c, int bundle_num)
293 {
294 int i;
295
296
2/2
✓ Branch 0 taken 153 times.
✓ Branch 1 taken 1224 times.
 1377 if (bundle_num == BINK_SRC_COLORS) {
297
2/2
✓ Branch 0 taken 2448 times.
✓ Branch 1 taken 153 times.
 2601 for (i = 0; i < 16; i++) {
298 2448 int ret = read_tree(gb, &c->col_high[i]);
299
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2448 times.
 2448 if (ret < 0)
300 ✗ return ret;
301 }
302 153 c->col_lastval = 0;
303 }
304
4/4
✓ Branch 0 taken 1224 times.
✓ Branch 1 taken 153 times.
✓ Branch 2 taken 1071 times.
✓ Branch 3 taken 153 times.
 1377 if (bundle_num != BINK_SRC_INTRA_DC && bundle_num != BINK_SRC_INTER_DC) {
305 1071 int ret = read_tree(gb, &c->bundle[bundle_num].tree);
306
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1071 times.
 1071 if (ret < 0)
307 ✗ return ret;
308 }
309 1377 c->bundle[bundle_num].cur_dec =
310 1377 c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data;
311
312 1377 return 0;
313 }
314
315 /**
316 * common check before starting decoding bundle data
317 *
318 * @param gb context for reading bits
319 * @param b bundle
320 * @param t variable where number of elements to decode will be stored
321 */
322 #define CHECK_READ_VAL(gb, b, t) \
323 if (!b->cur_dec || (b->cur_dec > b->cur_ptr)) \
324 return 0; \
325 t = get_bits(gb, b->len); \
326 if (!t) { \
327 b->cur_dec = NULL; \
328 return 0; \
329 } \
330
331 6120 static int read_runs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
332 {
333 int t, v;
334 const uint8_t *dec_end;
335
336
6/6
✓ Branch 0 taken 5773 times.
✓ Branch 1 taken 347 times.
✓ Branch 2 taken 5394 times.
✓ Branch 3 taken 379 times.
✓ Branch 5 taken 94 times.
✓ Branch 6 taken 285 times.
 6120 CHECK_READ_VAL(gb, b, t);
337 285 dec_end = b->cur_dec + t;
338
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 285 times.
 285 if (dec_end > b->data_end) {
339 ✗ av_log(avctx, AV_LOG_ERROR, "Run value went out of bounds\n");
340 ✗ return AVERROR_INVALIDDATA;
341 }
342
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 285 times.
 285 if (get_bits_left(gb) < 1)
343 ✗ return AVERROR_INVALIDDATA;
344
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 285 times.
 285 if (get_bits1(gb)) {
345 ✗ v = get_bits(gb, 4);
346 ✗ memset(b->cur_dec, v, t);
347 ✗ b->cur_dec += t;
348 } else {
349
2/2
✓ Branch 0 taken 96813 times.
✓ Branch 1 taken 285 times.
 97098 while (b->cur_dec < dec_end)
350 96813 *b->cur_dec++ = GET_HUFF(gb, b->tree);
351 }
352 285 return 0;
353 }
354
355 12240 static int read_motion_values(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
356 {
357 int t, sign, v;
358 const uint8_t *dec_end;
359
360
6/6
✓ Branch 0 taken 11772 times.
✓ Branch 1 taken 468 times.
✓ Branch 2 taken 11188 times.
✓ Branch 3 taken 584 times.
✓ Branch 5 taken 12 times.
✓ Branch 6 taken 572 times.
 12240 CHECK_READ_VAL(gb, b, t);
361 572 dec_end = b->cur_dec + t;
362
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 572 times.
 572 if (dec_end > b->data_end) {
363 ✗ av_log(avctx, AV_LOG_ERROR, "Too many motion values\n");
364 ✗ return AVERROR_INVALIDDATA;
365 }
366
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 572 times.
 572 if (get_bits_left(gb) < 1)
367 ✗ return AVERROR_INVALIDDATA;
368
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 572 times.
 572 if (get_bits1(gb)) {
369 ✗ v = get_bits(gb, 4);
370 ✗ if (v) {
371 ✗ sign = -get_bits1(gb);
372 ✗ v = (v ^ sign) - sign;
373 }
374 ✗ memset(b->cur_dec, v, t);
375 ✗ b->cur_dec += t;
376 } else {
377
2/2
✓ Branch 0 taken 220592 times.
✓ Branch 1 taken 572 times.
 221164 while (b->cur_dec < dec_end) {
378 220592 v = GET_HUFF(gb, b->tree);
379
2/2
✓ Branch 0 taken 207492 times.
✓ Branch 1 taken 13100 times.
 220592 if (v) {
380 207492 sign = -get_bits1(gb);
381 207492 v = (v ^ sign) - sign;
382 }
383 220592 *b->cur_dec++ = v;
384 }
385 }
386 572 return 0;
387 }
388
389 static const uint8_t bink_rlelens[4] = { 4, 8, 12, 32 };
390
391 12240 static int read_block_types(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
392 {
393 12240 BinkContext * const c = avctx->priv_data;
394 int t, v;
395 12240 int last = 0;
396 const uint8_t *dec_end;
397
398
6/6
✓ Branch 0 taken 12049 times.
✓ Branch 1 taken 191 times.
✓ Branch 2 taken 11064 times.
✓ Branch 3 taken 985 times.
✓ Branch 5 taken 153 times.
✓ Branch 6 taken 832 times.
 12240 CHECK_READ_VAL(gb, b, t);
399
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 832 times.
 832 if (c->version == 'k') {
400 ✗ t ^= 0xBBu;
401 ✗ if (t == 0) {
402 ✗ b->cur_dec = NULL;
403 ✗ return 0;
404 }
405 }
406 832 dec_end = b->cur_dec + t;
407
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 832 times.
 832 if (dec_end > b->data_end) {
408 ✗ av_log(avctx, AV_LOG_ERROR, "Too many block type values\n");
409 ✗ return AVERROR_INVALIDDATA;
410 }
411
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 832 times.
 832 if (get_bits_left(gb) < 1)
412 ✗ return AVERROR_INVALIDDATA;
413
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 832 times.
 832 if (get_bits1(gb)) {
414 ✗ v = get_bits(gb, 4);
415 ✗ memset(b->cur_dec, v, t);
416 ✗ b->cur_dec += t;
417 } else {
418
2/2
✓ Branch 0 taken 251420 times.
✓ Branch 1 taken 832 times.
 252252 while (b->cur_dec < dec_end) {
419 251420 v = GET_HUFF(gb, b->tree);
420
2/2
✓ Branch 0 taken 238193 times.
✓ Branch 1 taken 13227 times.
 251420 if (v < 12) {
421 238193 last = v;
422 238193 *b->cur_dec++ = v;
423 } else {
424 13227 int run = bink_rlelens[v - 12];
425
426
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13227 times.
 13227 if (dec_end - b->cur_dec < run)
427 ✗ return AVERROR_INVALIDDATA;
428 13227 memset(b->cur_dec, last, run);
429 13227 b->cur_dec += run;
430 }
431 }
432 }
433 832 return 0;
434 }
435
436 6120 static int read_patterns(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
437 {
438 int t, v;
439 const uint8_t *dec_end;
440
441
6/6
✓ Branch 0 taken 5596 times.
✓ Branch 1 taken 524 times.
✓ Branch 2 taken 5295 times.
✓ Branch 3 taken 301 times.
✓ Branch 5 taken 95 times.
✓ Branch 6 taken 206 times.
 6120 CHECK_READ_VAL(gb, b, t);
442 206 dec_end = b->cur_dec + t;
443
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 206 times.
 206 if (dec_end > b->data_end) {
444 ✗ av_log(avctx, AV_LOG_ERROR, "Too many pattern values\n");
445 ✗ return AVERROR_INVALIDDATA;
446 }
447
2/2
✓ Branch 0 taken 53296 times.
✓ Branch 1 taken 206 times.
 53502 while (b->cur_dec < dec_end) {
448
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 53296 times.
 53296 if (get_bits_left(gb) < 2)
449 ✗ return AVERROR_INVALIDDATA;
450 53296 v = GET_HUFF(gb, b->tree);
451 53296 v |= GET_HUFF(gb, b->tree) << 4;
452 53296 *b->cur_dec++ = v;
453 }
454
455 206 return 0;
456 }
457
458 6120 static int read_colors(GetBitContext *gb, Bundle *b, BinkContext *c)
459 {
460 int t, sign, v;
461 const uint8_t *dec_end;
462
463
6/6
✓ Branch 0 taken 6115 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 5694 times.
✓ Branch 3 taken 421 times.
✓ Branch 5 taken 11 times.
✓ Branch 6 taken 410 times.
 6120 CHECK_READ_VAL(gb, b, t);
464 410 dec_end = b->cur_dec + t;
465
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 410 times.
 410 if (dec_end > b->data_end) {
466 ✗ av_log(c->avctx, AV_LOG_ERROR, "Too many color values\n");
467 ✗ return AVERROR_INVALIDDATA;
468 }
469
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 410 times.
 410 if (get_bits_left(gb) < 1)
470 ✗ return AVERROR_INVALIDDATA;
471
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 410 times.
 410 if (get_bits1(gb)) {
472 ✗ c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]);
473 ✗ v = GET_HUFF(gb, b->tree);
474 ✗ v = (c->col_lastval << 4) | v;
475 ✗ if (c->version < 'i') {
476 ✗ sign = ((int8_t) v) >> 7;
477 ✗ v = ((v & 0x7F) ^ sign) - sign;
478 ✗ v += 0x80;
479 }
480 ✗ memset(b->cur_dec, v, t);
481 ✗ b->cur_dec += t;
482 } else {
483
2/2
✓ Branch 0 taken 190872 times.
✓ Branch 1 taken 410 times.
 191282 while (b->cur_dec < dec_end) {
484
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 190872 times.
 190872 if (get_bits_left(gb) < 2)
485 ✗ return AVERROR_INVALIDDATA;
486 190872 c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]);
487 190872 v = GET_HUFF(gb, b->tree);
488 190872 v = (c->col_lastval << 4) | v;
489
2/2
✓ Branch 0 taken 148464 times.
✓ Branch 1 taken 42408 times.
 190872 if (c->version < 'i') {
490 148464 sign = ((int8_t) v) >> 7;
491 148464 v = ((v & 0x7F) ^ sign) - sign;
492 148464 v += 0x80;
493 }
494 190872 *b->cur_dec++ = v;
495 }
496 }
497 410 return 0;
498 }
499
500 /** number of bits used to store first DC value in bundle */
501 #define DC_START_BITS 11
502
503 12240 static int read_dcs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b,
504 int start_bits, int has_sign)
505 {
506 int i, j, len, len2, bsize, sign, v, v2;
507 12240 int16_t *dst = (int16_t*)b->cur_dec;
508 12240 int16_t *dst_end = (int16_t*)b->data_end;
509
510
6/6
✓ Branch 0 taken 11664 times.
✓ Branch 1 taken 576 times.
✓ Branch 2 taken 11230 times.
✓ Branch 3 taken 434 times.
✓ Branch 5 taken 102 times.
✓ Branch 6 taken 332 times.
 12240 CHECK_READ_VAL(gb, b, len);
511
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 332 times.
 332 if (get_bits_left(gb) < start_bits - has_sign)
512 ✗ return AVERROR_INVALIDDATA;
513 332 v = get_bits(gb, start_bits - has_sign);
514
4/4
✓ Branch 0 taken 314 times.
✓ Branch 1 taken 18 times.
✓ Branch 2 taken 129 times.
✓ Branch 3 taken 185 times.
 332 if (v && has_sign) {
515 129 sign = -get_bits1(gb);
516 129 v = (v ^ sign) - sign;
517 }
518
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 332 times.
 332 if (dst_end - dst < 1)
519 ✗ return AVERROR_INVALIDDATA;
520 332 *dst++ = v;
521 332 len--;
522
2/2
✓ Branch 0 taken 5793 times.
✓ Branch 1 taken 332 times.
 6125 for (i = 0; i < len; i += 8) {
523 5793 len2 = FFMIN(len - i, 8);
524
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5793 times.
 5793 if (dst_end - dst < len2)
525 ✗ return AVERROR_INVALIDDATA;
526 5793 bsize = get_bits(gb, 4);
527
2/2
✓ Branch 0 taken 5789 times.
✓ Branch 1 taken 4 times.
 5793 if (bsize) {
528
2/2
✓ Branch 0 taken 45153 times.
✓ Branch 1 taken 5789 times.
 50942 for (j = 0; j < len2; j++) {
529 45153 v2 = get_bits(gb, bsize);
530
2/2
✓ Branch 0 taken 42581 times.
✓ Branch 1 taken 2572 times.
 45153 if (v2) {
531 42581 sign = -get_bits1(gb);
532 42581 v2 = (v2 ^ sign) - sign;
533 }
534 45153 v += v2;
535 45153 *dst++ = v;
536
2/4
✓ Branch 0 taken 45153 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 45153 times.
 45153 if (v < -32768 || v > 32767) {
537 ✗ av_log(avctx, AV_LOG_ERROR, "DC value went out of bounds: %d\n", v);
538 ✗ return AVERROR_INVALIDDATA;
539 }
540 }
541 } else {
542
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 4 times.
 22 for (j = 0; j < len2; j++)
543 18 *dst++ = v;
544 }
545 }
546
547 332 b->cur_dec = (uint8_t*)dst;
548 332 return 0;
549 }
550
551 /**
552 * Retrieve next value from bundle.
553 *
554 * @param c decoder context
555 * @param bundle bundle number
556 */
557 939741 static inline int get_value(BinkContext *c, int bundle)
558 {
559 int ret;
560
561
4/4
✓ Branch 0 taken 362908 times.
✓ Branch 1 taken 576833 times.
✓ Branch 2 taken 96813 times.
✓ Branch 3 taken 266095 times.
 939741 if (bundle < BINK_SRC_X_OFF || bundle == BINK_SRC_RUN)
562 673646 return *c->bundle[bundle].cur_ptr++;
563
4/4
✓ Branch 0 taken 155799 times.
✓ Branch 1 taken 110296 times.
✓ Branch 2 taken 110296 times.
✓ Branch 3 taken 45503 times.
 266095 if (bundle == BINK_SRC_X_OFF || bundle == BINK_SRC_Y_OFF)
564 220592 return (int8_t)*c->bundle[bundle].cur_ptr++;
565 45503 ret = *(int16_t*)c->bundle[bundle].cur_ptr;
566 45503 c->bundle[bundle].cur_ptr += 2;
567 45503 return ret;
568 }
569
570 960 static av_cold void binkb_init_bundle(BinkContext *c, int bundle_num)
571 {
572 960 c->bundle[bundle_num].cur_dec =
573 960 c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data;
574 960 c->bundle[bundle_num].len = 13;
575 960 }
576
577 96 static av_cold void binkb_init_bundles(BinkContext *c)
578 {
579 int i;
580
2/2
✓ Branch 0 taken 960 times.
✓ Branch 1 taken 96 times.
 1056 for (i = 0; i < BINKB_NB_SRC; i++)
581 960 binkb_init_bundle(c, i);
582 96 }
583
584 9920 static int binkb_read_bundle(BinkContext *c, GetBitContext *gb, int bundle_num)
585 {
586 9920 const int bits = binkb_bundle_sizes[bundle_num];
587 9920 const int mask = 1 << (bits - 1);
588 9920 const int issigned = binkb_bundle_signed[bundle_num];
589 9920 Bundle *b = &c->bundle[bundle_num];
590 int i, len;
591
592
6/6
✓ Branch 0 taken 5044 times.
✓ Branch 1 taken 4876 times.
✓ Branch 2 taken 4019 times.
✓ Branch 3 taken 1025 times.
✓ Branch 5 taken 528 times.
✓ Branch 6 taken 497 times.
 9920 CHECK_READ_VAL(gb, b, len);
593
3/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 492 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 497 times.
 497 if (b->data_end - b->cur_dec < len * (1 + (bits > 8)))
594 ✗ return AVERROR_INVALIDDATA;
595
2/2
✓ Branch 0 taken 492 times.
✓ Branch 1 taken 5 times.
 497 if (bits <= 8) {
596
2/2
✓ Branch 0 taken 300 times.
✓ Branch 1 taken 192 times.
 492 if (!issigned) {
597
2/2
✓ Branch 0 taken 42063 times.
✓ Branch 1 taken 300 times.
 42363 for (i = 0; i < len; i++)
598 42063 *b->cur_dec++ = get_bits(gb, bits);
599 } else {
600
2/2
✓ Branch 0 taken 28990 times.
✓ Branch 1 taken 192 times.
 29182 for (i = 0; i < len; i++)
601 28990 *b->cur_dec++ = get_bits(gb, bits) - mask;
602 }
603 } else {
604 5 int16_t *dst = (int16_t*)b->cur_dec;
605
606
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 if (!issigned) {
607 ✗ for (i = 0; i < len; i++)
608 ✗ *dst++ = get_bits(gb, bits);
609 } else {
610
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
 10 for (i = 0; i < len; i++)
611 5 *dst++ = get_bits(gb, bits) - mask;
612 }
613 5 b->cur_dec = (uint8_t*)dst;
614 }
615 497 return 0;
616 }
617
618 65426 static inline int binkb_get_value(BinkContext *c, int bundle_num)
619 {
620 int16_t ret;
621 65426 const int bits = binkb_bundle_sizes[bundle_num];
622
623
2/2
✓ Branch 0 taken 65421 times.
✓ Branch 1 taken 5 times.
 65426 if (bits <= 8) {
624 65421 int val = *c->bundle[bundle_num].cur_ptr++;
625
2/2
✓ Branch 0 taken 28990 times.
✓ Branch 1 taken 36431 times.
 65421 return binkb_bundle_signed[bundle_num] ? (int8_t)val : val;
626 }
627 5 ret = *(int16_t*)c->bundle[bundle_num].cur_ptr;
628 5 c->bundle[bundle_num].cur_ptr += 2;
629 5 return ret;
630 }
631
632 /**
633 * Read 8x8 block of DCT coefficients.
634 *
635 * @param gb context for reading bits
636 * @param block place for storing coefficients
637 * @param scan scan order table
638 * @param quant_matrices quantization matrices
639 * @return 0 for success, negative value in other cases
640 */
641 45508 static int read_dct_coeffs(BinkContext *c, GetBitContext *gb, int32_t block[64],
642 const uint8_t *scan, int *coef_count_,
643 int coef_idx[64], int q)
644 {
645 int coef_list[128];
646 int mode_list[128];
647 int i, t, bits, ccoef, mode, sign;
648 45508 int list_start = 64, list_end = 64, list_pos;
649 45508 int coef_count = 0;
650 int quant_idx;
651
652
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 45508 times.
 45508 if (get_bits_left(gb) < 4)
653 ✗ return AVERROR_INVALIDDATA;
654
655 45508 coef_list[list_end] = 4; mode_list[list_end++] = 0;
656 45508 coef_list[list_end] = 24; mode_list[list_end++] = 0;
657 45508 coef_list[list_end] = 44; mode_list[list_end++] = 0;
658 45508 coef_list[list_end] = 1; mode_list[list_end++] = 3;
659 45508 coef_list[list_end] = 2; mode_list[list_end++] = 3;
660 45508 coef_list[list_end] = 3; mode_list[list_end++] = 3;
661
662
2/2
✓ Branch 1 taken 101534 times.
✓ Branch 2 taken 45508 times.
 147042 for (bits = get_bits(gb, 4) - 1; bits >= 0; bits--) {
663 101534 list_pos = list_start;
664
2/2
✓ Branch 0 taken 982733 times.
✓ Branch 1 taken 101534 times.
 1084267 while (list_pos < list_end) {
665
4/4
✓ Branch 0 taken 846976 times.
✓ Branch 1 taken 135757 times.
✓ Branch 3 taken 535282 times.
✓ Branch 4 taken 311694 times.
 982733 if (!(mode_list[list_pos] | coef_list[list_pos]) || !get_bits1(gb)) {
666 671039 list_pos++;
667 671039 continue;
668 }
669 311694 ccoef = coef_list[list_pos];
670 311694 mode = mode_list[list_pos];
671
4/5
✓ Branch 0 taken 66858 times.
✓ Branch 1 taken 54324 times.
✓ Branch 2 taken 25484 times.
✓ Branch 3 taken 165028 times.
✗ Branch 4 not taken.
 311694 switch (mode) {
672 66858 case 0:
673 66858 coef_list[list_pos] = ccoef + 4;
674 66858 mode_list[list_pos] = 1;
675 121182 case 2:
676
2/2
✓ Branch 0 taken 54324 times.
✓ Branch 1 taken 66858 times.
 121182 if (mode == 2) {
677 54324 coef_list[list_pos] = 0;
678 54324 mode_list[list_pos++] = 0;
679 }
680
2/2
✓ Branch 0 taken 484728 times.
✓ Branch 1 taken 121182 times.
 605910 for (i = 0; i < 4; i++, ccoef++) {
681
2/2
✓ Branch 1 taken 291256 times.
✓ Branch 2 taken 193472 times.
 484728 if (get_bits1(gb)) {
682 291256 coef_list[--list_start] = ccoef;
683 291256 mode_list[ list_start] = 3;
684 } else {
685
2/2
✓ Branch 0 taken 131103 times.
✓ Branch 1 taken 62369 times.
 193472 if (!bits) {
686 131103 t = 1 - (get_bits1(gb) << 1);
687 } else {
688 62369 t = get_bits(gb, bits) | 1 << bits;
689 62369 sign = -get_bits1(gb);
690 62369 t = (t ^ sign) - sign;
691 }
692 193472 block[scan[ccoef]] = t;
693 193472 coef_idx[coef_count++] = ccoef;
694 }
695 }
696 121182 break;
697 25484 case 1:
698 25484 mode_list[list_pos] = 2;
699
2/2
✓ Branch 0 taken 76452 times.
✓ Branch 1 taken 25484 times.
 101936 for (i = 0; i < 3; i++) {
700 76452 ccoef += 4;
701 76452 coef_list[list_end] = ccoef;
702 76452 mode_list[list_end++] = 2;
703 }
704 25484 break;
705 165028 case 3:
706
2/2
✓ Branch 0 taken 92955 times.
✓ Branch 1 taken 72073 times.
 165028 if (!bits) {
707 92955 t = 1 - (get_bits1(gb) << 1);
708 } else {
709 72073 t = get_bits(gb, bits) | 1 << bits;
710 72073 sign = -get_bits1(gb);
711 72073 t = (t ^ sign) - sign;
712 }
713 165028 block[scan[ccoef]] = t;
714 165028 coef_idx[coef_count++] = ccoef;
715 165028 coef_list[list_pos] = 0;
716 165028 mode_list[list_pos++] = 0;
717 165028 break;
718 }
719 }
720 }
721
722
2/2
✓ Branch 0 taken 45503 times.
✓ Branch 1 taken 5 times.
 45508 if (q == -1) {
723 45503 quant_idx = get_bits(gb, 4);
724 } else {
725 5 quant_idx = q;
726
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 if (quant_idx > 15U) {
727 ✗ av_log(c->avctx, AV_LOG_ERROR, "quant_index %d out of range\n", quant_idx);
728 ✗ return AVERROR_INVALIDDATA;
729 }
730 }
731
732 45508 *coef_count_ = coef_count;
733
734 45508 return quant_idx;
735 }
736
737 45508 static void unquantize_dct_coeffs(int32_t block[64], const uint32_t quant[64],
738 int coef_count, int coef_idx[64],
739 const uint8_t *scan)
740 {
741 int i;
742 45508 block[0] = (int)(block[0] * quant[0]) >> 11;
743
2/2
✓ Branch 0 taken 358500 times.
✓ Branch 1 taken 45508 times.
 404008 for (i = 0; i < coef_count; i++) {
744 358500 int idx = coef_idx[i];
745 358500 block[scan[idx]] = (int)(block[scan[idx]] * quant[idx]) >> 11;
746 }
747 45508 }
748
749 /**
750 * Read 8x8 block with residue after motion compensation.
751 *
752 * @param gb context for reading bits
753 * @param block place to store read data
754 * @param masks_count number of masks to decode
755 * @return 0 on success, negative value in other cases
756 */
757 18240 static int read_residue(GetBitContext *gb, int16_t block[64], int masks_count)
758 {
759 int coef_list[128];
760 int mode_list[128];
761 int i, sign, mask, ccoef, mode;
762 18240 int list_start = 64, list_end = 64, list_pos;
763 int nz_coeff[64];
764 18240 int nz_coeff_count = 0;
765
766 18240 coef_list[list_end] = 4; mode_list[list_end++] = 0;
767 18240 coef_list[list_end] = 24; mode_list[list_end++] = 0;
768 18240 coef_list[list_end] = 44; mode_list[list_end++] = 0;
769 18240 coef_list[list_end] = 0; mode_list[list_end++] = 2;
770
771
1/2
✓ Branch 1 taken 27586 times.
✗ Branch 2 not taken.
 27586 for (mask = 1 << get_bits(gb, 3); mask; mask >>= 1) {
772
2/2
✓ Branch 0 taken 69038 times.
✓ Branch 1 taken 26673 times.
 95711 for (i = 0; i < nz_coeff_count; i++) {
773
2/2
✓ Branch 1 taken 43421 times.
✓ Branch 2 taken 25617 times.
 69038 if (!get_bits1(gb))
774 43421 continue;
775
2/2
✓ Branch 0 taken 11898 times.
✓ Branch 1 taken 13719 times.
 25617 if (block[nz_coeff[i]] < 0)
776 11898 block[nz_coeff[i]] -= mask;
777 else
778 13719 block[nz_coeff[i]] += mask;
779 25617 masks_count--;
780
2/2
✓ Branch 0 taken 913 times.
✓ Branch 1 taken 24704 times.
 25617 if (masks_count < 0)
781 913 return 0;
782 }
783 26673 list_pos = list_start;
784
2/2
✓ Branch 0 taken 363794 times.
✓ Branch 1 taken 9346 times.
 373140 while (list_pos < list_end) {
785
4/4
✓ Branch 0 taken 331463 times.
✓ Branch 1 taken 32331 times.
✓ Branch 3 taken 170894 times.
✓ Branch 4 taken 160569 times.
 363794 if (!(coef_list[list_pos] | mode_list[list_pos]) || !get_bits1(gb)) {
786 203225 list_pos++;
787 203225 continue;
788 }
789 160569 ccoef = coef_list[list_pos];
790 160569 mode = mode_list[list_pos];
791
4/5
✓ Branch 0 taken 35457 times.
✓ Branch 1 taken 61195 times.
✓ Branch 2 taken 30692 times.
✓ Branch 3 taken 33225 times.
✗ Branch 4 not taken.
 160569 switch (mode) {
792 35457 case 0:
793 35457 coef_list[list_pos] = ccoef + 4;
794 35457 mode_list[list_pos] = 1;
795 96652 case 2:
796
2/2
✓ Branch 0 taken 61195 times.
✓ Branch 1 taken 35457 times.
 96652 if (mode == 2) {
797 61195 coef_list[list_pos] = 0;
798 61195 mode_list[list_pos++] = 0;
799 }
800
2/2
✓ Branch 0 taken 364175 times.
✓ Branch 1 taken 80761 times.
 444936 for (i = 0; i < 4; i++, ccoef++) {
801
2/2
✓ Branch 1 taken 262364 times.
✓ Branch 2 taken 101811 times.
 364175 if (get_bits1(gb)) {
802 262364 coef_list[--list_start] = ccoef;
803 262364 mode_list[ list_start] = 3;
804 } else {
805 101811 nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
806 101811 sign = -get_bits1(gb);
807 101811 block[bink_scan[ccoef]] = (mask ^ sign) - sign;
808 101811 masks_count--;
809
2/2
✓ Branch 0 taken 15891 times.
✓ Branch 1 taken 85920 times.
 101811 if (masks_count < 0)
810 15891 return 0;
811 }
812 }
813 80761 break;
814 30692 case 1:
815 30692 mode_list[list_pos] = 2;
816
2/2
✓ Branch 0 taken 92076 times.
✓ Branch 1 taken 30692 times.
 122768 for (i = 0; i < 3; i++) {
817 92076 ccoef += 4;
818 92076 coef_list[list_end] = ccoef;
819 92076 mode_list[list_end++] = 2;
820 }
821 30692 break;
822 33225 case 3:
823 33225 nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
824 33225 sign = -get_bits1(gb);
825 33225 block[bink_scan[ccoef]] = (mask ^ sign) - sign;
826 33225 coef_list[list_pos] = 0;
827 33225 mode_list[list_pos++] = 0;
828 33225 masks_count--;
829
2/2
✓ Branch 0 taken 1436 times.
✓ Branch 1 taken 31789 times.
 33225 if (masks_count < 0)
830 1436 return 0;
831 31789 break;
832 }
833 }
834 }
835
836 ✗ return 0;
837 }
838
839 /**
840 * Copy 8x8 block from source to destination, where src and dst may be overlapped
841 */
842 14327 static inline void put_pixels8x8_overlapped(uint8_t *dst, uint8_t *src, int stride)
843 {
844 uint8_t tmp[64];
845 int i;
846
2/2
✓ Branch 0 taken 114616 times.
✓ Branch 1 taken 14327 times.
 128943 for (i = 0; i < 8; i++)
847 114616 memcpy(tmp + i*8, src + i*stride, 8);
848
2/2
✓ Branch 0 taken 114616 times.
✓ Branch 1 taken 14327 times.
 128943 for (i = 0; i < 8; i++)
849 114616 memcpy(dst + i*stride, tmp + i*8, 8);
850 14327 }
851
852 96 static int binkb_decode_plane(BinkContext *c, AVFrame *frame, GetBitContext *gb,
853 int plane_idx, int is_key, int is_chroma)
854 {
855 int blk, ret;
856 int i, j, bx, by;
857 uint8_t *dst, *ref, *ref_start, *ref_end;
858 int v, col[2];
859 const uint8_t *scan;
860 int xoff, yoff;
861 96 LOCAL_ALIGNED_32(int16_t, block, [64]);
862 96 LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
863 int coordmap[64];
864
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 93 times.
 96 int ybias = is_key ? -15 : 0;
865 int qp, quant_idx, coef_count, coef_idx[64];
866
867 96 const int stride = frame->linesize[plane_idx];
868
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 32 times.
 96 int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3;
869
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 32 times.
 96 int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
870
871 96 binkb_init_bundles(c);
872 96 ref_start = frame->data[plane_idx];
873 96 ref_end = frame->data[plane_idx] + ((bh - 1) * frame->linesize[plane_idx] + bw - 1) * 8;
874
875
2/2
✓ Branch 0 taken 6144 times.
✓ Branch 1 taken 96 times.
 6240 for (i = 0; i < 64; i++)
876 6144 coordmap[i] = (i & 7) + (i >> 3) * stride;
877
878
2/2
✓ Branch 0 taken 992 times.
✓ Branch 1 taken 96 times.
 1088 for (by = 0; by < bh; by++) {
879
2/2
✓ Branch 0 taken 9920 times.
✓ Branch 1 taken 992 times.
 10912 for (i = 0; i < BINKB_NB_SRC; i++) {
880
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9920 times.
 9920 if ((ret = binkb_read_bundle(c, gb, i)) < 0)
881 ✗ return ret;
882 }
883
884 992 dst = frame->data[plane_idx] + 8*by*stride;
885
2/2
✓ Branch 0 taken 18656 times.
✓ Branch 1 taken 992 times.
 19648 for (bx = 0; bx < bw; bx++, dst += 8) {
886 18656 blk = binkb_get_value(c, BINKB_SRC_BLOCK_TYPES);
887
7/10
✓ Branch 0 taken 3841 times.
✓ Branch 1 taken 190 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 14490 times.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 27 times.
✓ Branch 6 taken 15 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 88 times.
✗ Branch 9 not taken.
 18656 switch (blk) {
888 3841 case 0:
889 3841 break;
890 190 case 1:
891 190 scan = bink_patterns[get_bits(gb, 4)];
892 190 i = 0;
893 do {
894 int mode, run;
895
896 1784 mode = get_bits1(gb);
897 1784 run = get_bits(gb, binkb_runbits[i]) + 1;
898
899 1784 i += run;
900
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1784 times.
 1784 if (i > 64) {
901 ✗ av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
902 ✗ return AVERROR_INVALIDDATA;
903 }
904
2/2
✓ Branch 0 taken 1211 times.
✓ Branch 1 taken 573 times.
 1784 if (mode) {
905 1211 v = binkb_get_value(c, BINKB_SRC_COLORS);
906
2/2
✓ Branch 0 taken 10268 times.
✓ Branch 1 taken 1211 times.
 11479 for (j = 0; j < run; j++)
907 10268 dst[coordmap[*scan++]] = v;
908 } else {
909
2/2
✓ Branch 0 taken 1845 times.
✓ Branch 1 taken 573 times.
 2418 for (j = 0; j < run; j++)
910 1845 dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
911 }
912
2/2
✓ Branch 0 taken 1594 times.
✓ Branch 1 taken 190 times.
 1784 } while (i < 63);
913
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 143 times.
 190 if (i == 63)
914 47 dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
915 190 break;
916 ✗ case 2:
917 ✗ memset(dctblock, 0, sizeof(*dctblock) * 64);
918 ✗ dctblock[0] = binkb_get_value(c, BINKB_SRC_INTRA_DC);
919 ✗ qp = binkb_get_value(c, BINKB_SRC_INTRA_Q);
920 ✗ if ((quant_idx = read_dct_coeffs(c, gb, dctblock, bink_scan, &coef_count, coef_idx, qp)) < 0)
921 ✗ return quant_idx;
922 ✗ unquantize_dct_coeffs(dctblock, binkb_intra_quant[quant_idx], coef_count, coef_idx, bink_scan);
923 ✗ c->binkdsp.idct_put(dst, stride, dctblock);
924 ✗ break;
925 14490 case 3:
926 14490 xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
927 14490 yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
928 14490 ref = dst + xoff + yoff * stride;
929
2/4
✓ Branch 0 taken 14490 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14490 times.
 14490 if (ref < ref_start || ref > ref_end) {
930 ✗ av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
931
4/4
✓ Branch 0 taken 14323 times.
✓ Branch 1 taken 167 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 14322 times.
 14490 } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
932 168 c->put_pixels_tab(dst, ref, stride, 8);
933 } else {
934 14322 put_pixels8x8_overlapped(dst, ref, stride);
935 }
936 14490 c->bdsp.clear_block(block);
937 14490 v = binkb_get_value(c, BINKB_SRC_INTER_COEFS);
938 14490 read_residue(gb, block, v);
939 14490 c->binkdsp.add_pixels8(dst, block, stride);
940 14490 break;
941 5 case 4:
942 5 xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
943 5 yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
944 5 ref = dst + xoff + yoff * stride;
945
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
 5 if (ref < ref_start || ref > ref_end) {
946 ✗ av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
947
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
 5 } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
948 ✗ c->put_pixels_tab(dst, ref, stride, 8);
949 } else {
950 5 put_pixels8x8_overlapped(dst, ref, stride);
951 }
952 5 memset(dctblock, 0, sizeof(*dctblock) * 64);
953 5 dctblock[0] = binkb_get_value(c, BINKB_SRC_INTER_DC);
954 5 qp = binkb_get_value(c, BINKB_SRC_INTER_Q);
955
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
 5 if ((quant_idx = read_dct_coeffs(c, gb, dctblock, bink_scan, &coef_count, coef_idx, qp)) < 0)
956 ✗ return quant_idx;
957 5 unquantize_dct_coeffs(dctblock, binkb_inter_quant[quant_idx], coef_count, coef_idx, bink_scan);
958 5 c->binkdsp.idct_add(dst, stride, dctblock);
959 5 break;
960 27 case 5:
961 27 v = binkb_get_value(c, BINKB_SRC_COLORS);
962 27 c->bdsp.fill_block_tab[1](dst, v, stride, 8);
963 27 break;
964 15 case 6:
965
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 15 times.
 45 for (i = 0; i < 2; i++)
966 30 col[i] = binkb_get_value(c, BINKB_SRC_COLORS);
967
2/2
✓ Branch 0 taken 120 times.
✓ Branch 1 taken 15 times.
 135 for (i = 0; i < 8; i++) {
968 120 v = binkb_get_value(c, BINKB_SRC_PATTERN);
969
2/2
✓ Branch 0 taken 960 times.
✓ Branch 1 taken 120 times.
 1080 for (j = 0; j < 8; j++, v >>= 1)
970 960 dst[i*stride + j] = col[v & 1];
971 }
972 15 break;
973 ✗ case 7:
974 ✗ xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
975 ✗ yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
976 ✗ ref = dst + xoff + yoff * stride;
977 ✗ if (ref < ref_start || ref > ref_end) {
978 ✗ av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
979 ✗ } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
980 ✗ c->put_pixels_tab(dst, ref, stride, 8);
981 } else {
982 ✗ put_pixels8x8_overlapped(dst, ref, stride);
983 }
984 ✗ break;
985 88 case 8:
986
2/2
✓ Branch 0 taken 704 times.
✓ Branch 1 taken 88 times.
 792 for (i = 0; i < 8; i++)
987 704 memcpy(dst + i*stride, c->bundle[BINKB_SRC_COLORS].cur_ptr + i*8, 8);
988 88 c->bundle[BINKB_SRC_COLORS].cur_ptr += 64;
989 88 break;
990 ✗ default:
991 ✗ av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
992 ✗ return AVERROR_INVALIDDATA;
993 }
994 }
995 }
996
2/2
✓ Branch 1 taken 92 times.
✓ Branch 2 taken 4 times.
 96 if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary
997 92 skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
998
999 96 return 0;
1000 }
1001
1002 110296 static int bink_put_pixels(BinkContext *c,
1003 uint8_t *dst, uint8_t *prev, int stride,
1004 uint8_t *ref_start,
1005 uint8_t *ref_end)
1006 {
1007 110296 int xoff = get_value(c, BINK_SRC_X_OFF);
1008 110296 int yoff = get_value(c, BINK_SRC_Y_OFF);
1009 110296 uint8_t *ref = prev + xoff + yoff * stride;
1010
2/4
✓ Branch 0 taken 110296 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 110296 times.
 110296 if (ref < ref_start || ref > ref_end) {
1011 ✗ av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
1012 xoff, yoff);
1013 ✗ return AVERROR_INVALIDDATA;
1014 }
1015 110296 c->put_pixels_tab(dst, ref, stride, 8);
1016
1017 110296 return 0;
1018 }
1019
1020 153 static int bink_decode_plane(BinkContext *c, AVFrame *frame, GetBitContext *gb,
1021 int plane_idx, int is_chroma)
1022 {
1023 int blk, ret;
1024 int i, j, bx, by;
1025 uint8_t *dst, *prev, *ref_start, *ref_end;
1026 int v, col[2];
1027 const uint8_t *scan;
1028 153 LOCAL_ALIGNED_32(int16_t, block, [64]);
1029 153 LOCAL_ALIGNED_16(uint8_t, ublock, [64]);
1030 153 LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
1031 int coordmap[64], quant_idx, coef_count, coef_idx[64];
1032
1033 153 const int stride = frame->linesize[plane_idx];
1034
2/2
✓ Branch 0 taken 102 times.
✓ Branch 1 taken 51 times.
 153 int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3;
1035
2/2
✓ Branch 0 taken 102 times.
✓ Branch 1 taken 51 times.
 153 int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
1036 153 int width = c->avctx->width >> is_chroma;
1037 153 int height = c->avctx->height >> is_chroma;
1038
1039
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 153 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 153 if (c->version == 'k' && get_bits1(gb)) {
1040 ✗ int fill = get_bits(gb, 8);
1041
1042 ✗ dst = frame->data[plane_idx];
1043
1044 ✗ for (i = 0; i < height; i++)
1045 ✗ memset(dst + i * stride, fill, width);
1046 ✗ goto end;
1047 }
1048
1049 153 init_lengths(c, FFMAX(width, 8), bw);
1050
2/2
✓ Branch 0 taken 1377 times.
✓ Branch 1 taken 153 times.
 1530 for (i = 0; i < BINK_NB_SRC; i++) {
1051 1377 ret = read_bundle(gb, c, i);
1052
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1377 times.
 1377 if (ret < 0)
1053 ✗ return ret;
1054 }
1055
1056 453 ref_start = c->last->data[plane_idx] ? c->last->data[plane_idx]
1057
2/2
✓ Branch 0 taken 147 times.
✓ Branch 1 taken 6 times.
 153 : frame->data[plane_idx];
1058 153 ref_end = ref_start
1059 153 + (bw - 1 + c->last->linesize[plane_idx] * (bh - 1)) * 8;
1060
1061
2/2
✓ Branch 0 taken 9792 times.
✓ Branch 1 taken 153 times.
 9945 for (i = 0; i < 64; i++)
1062 9792 coordmap[i] = (i & 7) + (i >> 3) * stride;
1063
1064
2/2
✓ Branch 0 taken 6120 times.
✓ Branch 1 taken 153 times.
 6273 for (by = 0; by < bh; by++) {
1065
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6120 times.
 6120 if ((ret = read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_BLOCK_TYPES])) < 0)
1066 ✗ return ret;
1067
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6120 times.
 6120 if ((ret = read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_SUB_BLOCK_TYPES])) < 0)
1068 ✗ return ret;
1069
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6120 times.
 6120 if ((ret = read_colors(gb, &c->bundle[BINK_SRC_COLORS], c)) < 0)
1070 ✗ return ret;
1071
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6120 times.
 6120 if ((ret = read_patterns(c->avctx, gb, &c->bundle[BINK_SRC_PATTERN])) < 0)
1072 ✗ return ret;
1073
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6120 times.
 6120 if ((ret = read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_X_OFF])) < 0)
1074 ✗ return ret;
1075
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6120 times.
 6120 if ((ret = read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_Y_OFF])) < 0)
1076 ✗ return ret;
1077
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6120 times.
 6120 if ((ret = read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0)) < 0)
1078 ✗ return ret;
1079
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6120 times.
 6120 if ((ret = read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1)) < 0)
1080 ✗ return ret;
1081
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6120 times.
 6120 if ((ret = read_runs(c->avctx, gb, &c->bundle[BINK_SRC_RUN])) < 0)
1082 ✗ return ret;
1083
1084 6120 dst = frame->data[plane_idx] + 8*by*stride;
1085 18120 prev = (c->last->data[plane_idx] ? c->last->data[plane_idx]
1086
2/2
✓ Branch 0 taken 5880 times.
✓ Branch 1 taken 240 times.
 6120 : frame->data[plane_idx]) + 8*by*stride;
1087
2/2
✓ Branch 0 taken 314770 times.
✓ Branch 1 taken 6120 times.
 320890 for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) {
1088 314770 blk = get_value(c, BINK_SRC_BLOCK_TYPES);
1089 // 16x16 block type on odd line means part of the already decoded block, so skip it
1090
6/6
✓ Branch 0 taken 157385 times.
✓ Branch 1 taken 157385 times.
✓ Branch 2 taken 65585 times.
✓ Branch 3 taken 91800 times.
✓ Branch 4 taken 26215 times.
✓ Branch 5 taken 196755 times.
 314770 if (((by & 1) || (bx & 1)) && blk == SCALED_BLOCK) {
1091 26215 bx++;
1092 26215 dst += 8;
1093 26215 prev += 8;
1094 26215 continue;
1095 }
1096
10/11
✓ Branch 0 taken 85550 times.
✓ Branch 1 taken 26215 times.
✓ Branch 2 taken 97378 times.
✓ Branch 3 taken 11625 times.
✓ Branch 4 taken 3750 times.
✓ Branch 5 taken 16881 times.
✓ Branch 6 taken 31947 times.
✓ Branch 7 taken 9168 times.
✓ Branch 8 taken 5911 times.
✓ Branch 9 taken 130 times.
✗ Branch 10 not taken.
 288555 switch (blk) {
1097 85550 case SKIP_BLOCK:
1098 85550 c->put_pixels_tab(dst, prev, stride, 8);
1099 85550 break;
1100 26215 case SCALED_BLOCK:
1101 26215 blk = get_value(c, BINK_SRC_SUB_BLOCK_TYPES);
1102
4/6
✓ Branch 0 taken 902 times.
✓ Branch 1 taken 19454 times.
✓ Branch 2 taken 5108 times.
✓ Branch 3 taken 751 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 26215 switch (blk) {
1103 902 case RUN_BLOCK:
1104
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 902 times.
 902 if (get_bits_left(gb) < 4)
1105 ✗ return AVERROR_INVALIDDATA;
1106 902 scan = bink_patterns[get_bits(gb, 4)];
1107 902 i = 0;
1108 do {
1109 6551 int run = get_value(c, BINK_SRC_RUN) + 1;
1110
1111 6551 i += run;
1112
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6551 times.
 6551 if (i > 64) {
1113 ✗ av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
1114 ✗ return AVERROR_INVALIDDATA;
1115 }
1116
2/2
✓ Branch 1 taken 5908 times.
✓ Branch 2 taken 643 times.
 6551 if (get_bits1(gb)) {
1117 5908 v = get_value(c, BINK_SRC_COLORS);
1118
2/2
✓ Branch 0 taken 56584 times.
✓ Branch 1 taken 5908 times.
 62492 for (j = 0; j < run; j++)
1119 56584 ublock[*scan++] = v;
1120 } else {
1121
2/2
✓ Branch 0 taken 1047 times.
✓ Branch 1 taken 643 times.
 1690 for (j = 0; j < run; j++)
1122 1047 ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
1123 }
1124
2/2
✓ Branch 0 taken 5649 times.
✓ Branch 1 taken 902 times.
 6551 } while (i < 63);
1125
2/2
✓ Branch 0 taken 97 times.
✓ Branch 1 taken 805 times.
 902 if (i == 63)
1126 97 ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
1127 902 break;
1128 19454 case INTRA_BLOCK:
1129 19454 memset(dctblock, 0, sizeof(*dctblock) * 64);
1130 19454 dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
1131
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 19454 times.
 19454 if ((quant_idx = read_dct_coeffs(c, gb, dctblock, bink_scan, &coef_count, coef_idx, -1)) < 0)
1132 ✗ return quant_idx;
1133 19454 unquantize_dct_coeffs(dctblock, bink_intra_quant[quant_idx], coef_count, coef_idx, bink_scan);
1134 19454 c->binkdsp.idct_put(ublock, 8, dctblock);
1135 19454 break;
1136 5108 case FILL_BLOCK:
1137 5108 v = get_value(c, BINK_SRC_COLORS);
1138 5108 c->bdsp.fill_block_tab[0](dst, v, stride, 16);
1139 5108 break;
1140 751 case PATTERN_BLOCK:
1141
2/2
✓ Branch 0 taken 1502 times.
✓ Branch 1 taken 751 times.
 2253 for (i = 0; i < 2; i++)
1142 1502 col[i] = get_value(c, BINK_SRC_COLORS);
1143
2/2
✓ Branch 0 taken 6008 times.
✓ Branch 1 taken 751 times.
 6759 for (j = 0; j < 8; j++) {
1144 6008 v = get_value(c, BINK_SRC_PATTERN);
1145
2/2
✓ Branch 0 taken 48064 times.
✓ Branch 1 taken 6008 times.
 54072 for (i = 0; i < 8; i++, v >>= 1)
1146 48064 ublock[i + j*8] = col[v & 1];
1147 }
1148 751 break;
1149 ✗ case RAW_BLOCK:
1150 ✗ for (j = 0; j < 8; j++)
1151 ✗ for (i = 0; i < 8; i++)
1152 ✗ ublock[i + j*8] = get_value(c, BINK_SRC_COLORS);
1153 ✗ break;
1154 ✗ default:
1155 ✗ av_log(c->avctx, AV_LOG_ERROR, "Incorrect 16x16 block type %d\n", blk);
1156 ✗ return AVERROR_INVALIDDATA;
1157 }
1158
2/2
✓ Branch 0 taken 21107 times.
✓ Branch 1 taken 5108 times.
 26215 if (blk != FILL_BLOCK)
1159 21107 c->binkdsp.scale_block(ublock, dst, stride);
1160 26215 bx++;
1161 26215 dst += 8;
1162 26215 prev += 8;
1163 26215 break;
1164 97378 case MOTION_BLOCK:
1165 97378 ret = bink_put_pixels(c, dst, prev, stride,
1166 ref_start, ref_end);
1167
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 97378 times.
 97378 if (ret < 0)
1168 ✗ return ret;
1169 97378 break;
1170 11625 case RUN_BLOCK:
1171 11625 scan = bink_patterns[get_bits(gb, 4)];
1172 11625 i = 0;
1173 do {
1174 90262 int run = get_value(c, BINK_SRC_RUN) + 1;
1175
1176 90262 i += run;
1177
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 90262 times.
 90262 if (i > 64) {
1178 ✗ av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
1179 ✗ return AVERROR_INVALIDDATA;
1180 }
1181
2/2
✓ Branch 1 taken 76178 times.
✓ Branch 2 taken 14084 times.
 90262 if (get_bits1(gb)) {
1182 76178 v = get_value(c, BINK_SRC_COLORS);
1183
2/2
✓ Branch 0 taken 695057 times.
✓ Branch 1 taken 76178 times.
 771235 for (j = 0; j < run; j++)
1184 695057 dst[coordmap[*scan++]] = v;
1185 } else {
1186
2/2
✓ Branch 0 taken 48041 times.
✓ Branch 1 taken 14084 times.
 62125 for (j = 0; j < run; j++)
1187 48041 dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
1188 }
1189
2/2
✓ Branch 0 taken 78637 times.
✓ Branch 1 taken 11625 times.
 90262 } while (i < 63);
1190
2/2
✓ Branch 0 taken 902 times.
✓ Branch 1 taken 10723 times.
 11625 if (i == 63)
1191 902 dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
1192 11625 break;
1193 3750 case RESIDUE_BLOCK:
1194 3750 ret = bink_put_pixels(c, dst, prev, stride,
1195 ref_start, ref_end);
1196
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3750 times.
 3750 if (ret < 0)
1197 ✗ return ret;
1198 3750 c->bdsp.clear_block(block);
1199 3750 v = get_bits(gb, 7);
1200 3750 read_residue(gb, block, v);
1201 3750 c->binkdsp.add_pixels8(dst, block, stride);
1202 3750 break;
1203 16881 case INTRA_BLOCK:
1204 16881 memset(dctblock, 0, sizeof(*dctblock) * 64);
1205 16881 dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
1206
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16881 times.
 16881 if ((quant_idx = read_dct_coeffs(c, gb, dctblock, bink_scan, &coef_count, coef_idx, -1)) < 0)
1207 ✗ return quant_idx;
1208 16881 unquantize_dct_coeffs(dctblock, bink_intra_quant[quant_idx], coef_count, coef_idx, bink_scan);
1209 16881 c->binkdsp.idct_put(dst, stride, dctblock);
1210 16881 break;
1211 31947 case FILL_BLOCK:
1212 31947 v = get_value(c, BINK_SRC_COLORS);
1213 31947 c->bdsp.fill_block_tab[1](dst, v, stride, 8);
1214 31947 break;
1215 9168 case INTER_BLOCK:
1216 9168 ret = bink_put_pixels(c, dst, prev, stride,
1217 ref_start, ref_end);
1218
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9168 times.
 9168 if (ret < 0)
1219 ✗ return ret;
1220 9168 memset(dctblock, 0, sizeof(*dctblock) * 64);
1221 9168 dctblock[0] = get_value(c, BINK_SRC_INTER_DC);
1222
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9168 times.
 9168 if ((quant_idx = read_dct_coeffs(c, gb, dctblock, bink_scan, &coef_count, coef_idx, -1)) < 0)
1223 ✗ return quant_idx;
1224 9168 unquantize_dct_coeffs(dctblock, bink_inter_quant[quant_idx], coef_count, coef_idx, bink_scan);
1225 9168 c->binkdsp.idct_add(dst, stride, dctblock);
1226 9168 break;
1227 5911 case PATTERN_BLOCK:
1228
2/2
✓ Branch 0 taken 11822 times.
✓ Branch 1 taken 5911 times.
 17733 for (i = 0; i < 2; i++)
1229 11822 col[i] = get_value(c, BINK_SRC_COLORS);
1230
2/2
✓ Branch 0 taken 47288 times.
✓ Branch 1 taken 5911 times.
 53199 for (i = 0; i < 8; i++) {
1231 47288 v = get_value(c, BINK_SRC_PATTERN);
1232
2/2
✓ Branch 0 taken 378304 times.
✓ Branch 1 taken 47288 times.
 425592 for (j = 0; j < 8; j++, v >>= 1)
1233 378304 dst[i*stride + j] = col[v & 1];
1234 }
1235 5911 break;
1236 130 case RAW_BLOCK:
1237
2/2
✓ Branch 0 taken 1040 times.
✓ Branch 1 taken 130 times.
 1170 for (i = 0; i < 8; i++)
1238 1040 memcpy(dst + i*stride, c->bundle[BINK_SRC_COLORS].cur_ptr + i*8, 8);
1239 130 c->bundle[BINK_SRC_COLORS].cur_ptr += 64;
1240 130 break;
1241 ✗ default:
1242 ✗ av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
1243 ✗ return AVERROR_INVALIDDATA;
1244 }
1245 }
1246 }
1247
1248 153 end:
1249
2/2
✓ Branch 1 taken 151 times.
✓ Branch 2 taken 2 times.
 153 if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary
1250 151 skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
1251
1252 153 return 0;
1253 }
1254
1255 83 static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
1256 int *got_frame, AVPacket *pkt)
1257 {
1258 83 BinkContext * const c = avctx->priv_data;
1259 GetBitContext gb;
1260 int plane, plane_idx, ret;
1261 83 int bits_count = pkt->size << 3;
1262
1263
2/2
✓ Branch 0 taken 51 times.
✓ Branch 1 taken 32 times.
 83 if (c->version > 'b') {
1264
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 51 times.
 51 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
1265 ✗ return ret;
1266 } else {
1267
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 32 times.
 32 if ((ret = ff_reget_buffer(avctx, c->last, 0)) < 0)
1268 ✗ return ret;
1269
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 32 times.
 32 if ((ret = av_frame_ref(frame, c->last)) < 0)
1270 ✗ return ret;
1271 }
1272
1273 83 init_get_bits(&gb, pkt->data, bits_count);
1274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 83 times.
 83 if (c->has_alpha) {
1275 ✗ if (c->version >= 'i')
1276 ✗ skip_bits_long(&gb, 32);
1277 ✗ if ((ret = bink_decode_plane(c, frame, &gb, 3, 0)) < 0)
1278 ✗ return ret;
1279 }
1280
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 52 times.
 83 if (c->version >= 'i')
1281 31 skip_bits_long(&gb, 32);
1282
1283 83 c->frame_num++;
1284
1285
1/2
✓ Branch 0 taken 249 times.
✗ Branch 1 not taken.
 249 for (plane = 0; plane < 3; plane++) {
1286
4/4
✓ Branch 0 taken 166 times.
✓ Branch 1 taken 83 times.
✓ Branch 2 taken 62 times.
✓ Branch 3 taken 104 times.
 249 plane_idx = (!plane || !c->swap_planes) ? plane : (plane ^ 3);
1287
1288
2/2
✓ Branch 0 taken 153 times.
✓ Branch 1 taken 96 times.
 249 if (c->version > 'b') {
1289
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 153 times.
 153 if ((ret = bink_decode_plane(c, frame, &gb, plane_idx, !!plane)) < 0)
1290 ✗ return ret;
1291 } else {
1292
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 96 times.
 96 if ((ret = binkb_decode_plane(c, frame, &gb, plane_idx,
1293 96 c->frame_num == 1, !!plane)) < 0)
1294 ✗ return ret;
1295 }
1296
2/2
✓ Branch 1 taken 83 times.
✓ Branch 2 taken 166 times.
 249 if (get_bits_count(&gb) >= bits_count)
1297 83 break;
1298 }
1299
1300
2/2
✓ Branch 0 taken 51 times.
✓ Branch 1 taken 32 times.
 83 if (c->version > 'b') {
1301
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 51 times.
 51 if ((ret = av_frame_replace(c->last, frame)) < 0)
1302 ✗ return ret;
1303 }
1304
1305 83 *got_frame = 1;
1306
1307 /* always report that the buffer was completely consumed */
1308 83 return pkt->size;
1309 }
1310
1311 6 static av_cold void bink_init_vlcs(void)
1312 {
1313
2/2
✓ Branch 0 taken 96 times.
✓ Branch 1 taken 6 times.
 102 for (int i = 0, offset = 0; i < 16; i++) {
1314 static VLCElem table[976];
1315 96 const int maxbits = bink_tree_lens[i][15];
1316 96 bink_trees[i].table = table + offset;
1317 96 bink_trees[i].table_allocated = 1 << maxbits;
1318 96 offset += bink_trees[i].table_allocated;
1319 96 vlc_init(&bink_trees[i], maxbits, 16,
1320 bink_tree_lens[i], 1, 1,
1321 bink_tree_bits[i], 1, 1, VLC_INIT_USE_STATIC | VLC_INIT_LE);
1322 }
1323 6 }
1324
1325 /**
1326 * Calculate quantization tables for version b
1327 */
1328 1 static av_cold void binkb_calc_quant(void)
1329 {
1330 uint8_t inv_bink_scan[64];
1331 static const int s[64]={
1332 1073741824,1489322693,1402911301,1262586814,1073741824, 843633538, 581104888, 296244703,
1333 1489322693,2065749918,1945893874,1751258219,1489322693,1170153332, 806015634, 410903207,
1334 1402911301,1945893874,1832991949,1649649171,1402911301,1102260336, 759250125, 387062357,
1335 1262586814,1751258219,1649649171,1484645031,1262586814, 992008094, 683307060, 348346918,
1336 1073741824,1489322693,1402911301,1262586814,1073741824, 843633538, 581104888, 296244703,
1337 843633538,1170153332,1102260336, 992008094, 843633538, 662838617, 456571181, 232757969,
1338 581104888, 806015634, 759250125, 683307060, 581104888, 456571181, 314491699, 160326478,
1339 296244703, 410903207, 387062357, 348346918, 296244703, 232757969, 160326478, 81733730,
1340 };
1341 int i, j;
1342 #define C (1LL<<30)
1343
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 1 times.
 65 for (i = 0; i < 64; i++)
1344 64 inv_bink_scan[bink_scan[i]] = i;
1345
1346
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 1 times.
 17 for (j = 0; j < 16; j++) {
1347
2/2
✓ Branch 0 taken 1024 times.
✓ Branch 1 taken 16 times.
 1040 for (i = 0; i < 64; i++) {
1348 1024 int k = inv_bink_scan[i];
1349 1024 binkb_intra_quant[j][k] = binkb_intra_seed[i] * (int64_t)s[i] *
1350 1024 binkb_num[j]/(binkb_den[j] * (C>>12));
1351 1024 binkb_inter_quant[j][k] = binkb_inter_seed[i] * (int64_t)s[i] *
1352 1024 binkb_num[j]/(binkb_den[j] * (C>>12));
1353 }
1354 }
1355 1 }
1356
1357 9 static av_cold int decode_init(AVCodecContext *avctx)
1358 {
1359 static AVOnce init_static_once = AV_ONCE_INIT;
1360 9 BinkContext * const c = avctx->priv_data;
1361 HpelDSPContext hdsp;
1362 int ret;
1363 int flags;
1364
1365 9 c->version = avctx->codec_tag >> 24;
1366
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (avctx->extradata_size < 4) {
1367 ✗ av_log(avctx, AV_LOG_ERROR, "Extradata missing or too short\n");
1368 ✗ return AVERROR_INVALIDDATA;
1369 }
1370 9 flags = AV_RL32(avctx->extradata);
1371 9 c->has_alpha = flags & BINK_FLAG_ALPHA;
1372 9 c->swap_planes = c->version >= 'h';
1373 9 c->avctx = avctx;
1374
1375
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
 9 if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
1376 ✗ return ret;
1377
1378 9 c->last = av_frame_alloc();
1379
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (!c->last)
1380 ✗ return AVERROR(ENOMEM);
1381
1382
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 avctx->pix_fmt = c->has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
1383
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 avctx->color_range = c->version == 'k' ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
1384
1385 9 ff_blockdsp_init(&c->bdsp);
1386 9 ff_hpeldsp_init(&hdsp, avctx->flags);
1387 9 c->put_pixels_tab = hdsp.put_pixels_tab[1][0];
1388 9 ff_binkdsp_init(&c->binkdsp);
1389
1390
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
 9 if ((ret = init_bundles(c)) < 0)
1391 ✗ return ret;
1392
1393
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 7 times.
 9 if (c->version == 'b') {
1394 static AVOnce binkb_init_once = AV_ONCE_INIT;
1395 2 ff_thread_once(&binkb_init_once, binkb_calc_quant);
1396 }
1397 9 ff_thread_once(&init_static_once, bink_init_vlcs);
1398
1399 9 return 0;
1400 }
1401
1402 9 static av_cold int decode_end(AVCodecContext *avctx)
1403 {
1404 9 BinkContext * const c = avctx->priv_data;
1405
1406 9 av_frame_free(&c->last);
1407
1408 9 free_bundles(c);
1409 9 return 0;
1410 }
1411
1412 ✗ static av_cold void flush(AVCodecContext *avctx)
1413 {
1414 ✗ BinkContext * const c = avctx->priv_data;
1415
1416 ✗ c->frame_num = 0;
1417 ✗ }
1418
1419 const FFCodec ff_bink_decoder = {
1420 .p.name = "binkvideo",
1421 CODEC_LONG_NAME("Bink video"),
1422 .p.type = AVMEDIA_TYPE_VIDEO,
1423 .p.id = AV_CODEC_ID_BINKVIDEO,
1424 .priv_data_size = sizeof(BinkContext),
1425 .init = decode_init,
1426 .close = decode_end,
1427 FF_CODEC_DECODE_CB(decode_frame),
1428 .flush = flush,
1429 .p.capabilities = AV_CODEC_CAP_DR1,
1430 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1431 };
1432