FFmpeg
bink.c
Go to the documentation of this file.
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/internal.h"
26 
27 #define BITSTREAM_READER_LE
28 #include "avcodec.h"
29 #include "binkdata.h"
30 #include "binkdsp.h"
31 #include "blockdsp.h"
32 #include "get_bits.h"
33 #include "hpeldsp.h"
34 #include "internal.h"
35 #include "mathops.h"
36 
37 #define BINK_FLAG_ALPHA 0x00100000
38 #define BINK_FLAG_GRAY 0x00020000
39 
40 static VLC bink_trees[16];
41 
42 /**
43  * IDs for different data types used in old version of Bink video codec
44  */
45 enum OldSources {
46  BINKB_SRC_BLOCK_TYPES = 0, ///< 8x8 block types
47  BINKB_SRC_COLORS, ///< pixel values used for different block types
48  BINKB_SRC_PATTERN, ///< 8-bit values for 2-colour pattern fill
49  BINKB_SRC_X_OFF, ///< X components of motion value
50  BINKB_SRC_Y_OFF, ///< Y components of motion value
51  BINKB_SRC_INTRA_DC, ///< DC values for intrablocks with DCT
52  BINKB_SRC_INTER_DC, ///< DC values for interblocks with DCT
53  BINKB_SRC_INTRA_Q, ///< quantizer values for intrablocks with DCT
54  BINKB_SRC_INTER_Q, ///< quantizer values for interblocks with DCT
55  BINKB_SRC_INTER_COEFS, ///< number of coefficients for residue blocks
56 
58 };
59 
60 static const int binkb_bundle_sizes[BINKB_NB_SRC] = {
61  4, 8, 8, 5, 5, 11, 11, 4, 4, 7
62 };
63 
64 static const int binkb_bundle_signed[BINKB_NB_SRC] = {
65  0, 0, 0, 1, 1, 0, 1, 0, 0, 0
66 };
67 
68 static int32_t binkb_intra_quant[16][64];
69 static int32_t binkb_inter_quant[16][64];
70 
71 /**
72  * IDs for different data types used in Bink video codec
73  */
74 enum Sources {
75  BINK_SRC_BLOCK_TYPES = 0, ///< 8x8 block types
76  BINK_SRC_SUB_BLOCK_TYPES, ///< 16x16 block types (a subset of 8x8 block types)
77  BINK_SRC_COLORS, ///< pixel values used for different block types
78  BINK_SRC_PATTERN, ///< 8-bit values for 2-colour pattern fill
79  BINK_SRC_X_OFF, ///< X components of motion value
80  BINK_SRC_Y_OFF, ///< Y components of motion value
81  BINK_SRC_INTRA_DC, ///< DC values for intrablocks with DCT
82  BINK_SRC_INTER_DC, ///< DC values for interblocks with DCT
83  BINK_SRC_RUN, ///< run lengths for special fill block
84 
86 };
87 
88 /**
89  * data needed to decode 4-bit Huffman-coded value
90  */
91 typedef struct Tree {
92  int vlc_num; ///< tree number (in bink_trees[])
93  uint8_t syms[16]; ///< leaf value to symbol mapping
94 } Tree;
95 
96 #define GET_HUFF(gb, tree) (tree).syms[get_vlc2(gb, bink_trees[(tree).vlc_num].table,\
97  bink_trees[(tree).vlc_num].bits, 1)]
98 
99 /**
100  * data structure used for decoding single Bink data type
101  */
102 typedef struct Bundle {
103  int len; ///< length of number of entries to decode (in bits)
104  Tree tree; ///< Huffman tree-related data
105  uint8_t *data; ///< buffer for decoded symbols
106  uint8_t *data_end; ///< buffer end
107  uint8_t *cur_dec; ///< pointer to the not yet decoded part of the buffer
108  uint8_t *cur_ptr; ///< pointer to the data that is not read from buffer yet
109 } Bundle;
110 
111 /*
112  * Decoder context
113  */
114 typedef struct BinkContext {
120  int version; ///< internal Bink file version
123  unsigned frame_num;
124 
125  Bundle bundle[BINKB_NB_SRC]; ///< bundles for decoding all data types
126  Tree col_high[16]; ///< trees for decoding high nibble in "colours" data type
127  int col_lastval; ///< value of last decoded high nibble in "colours" data type
128 } BinkContext;
129 
130 /**
131  * Bink video block types
132  */
134  SKIP_BLOCK = 0, ///< skipped block
135  SCALED_BLOCK, ///< block has size 16x16
136  MOTION_BLOCK, ///< block is copied from previous frame with some offset
137  RUN_BLOCK, ///< block is composed from runs of colours with custom scan order
138  RESIDUE_BLOCK, ///< motion block with some difference added
139  INTRA_BLOCK, ///< intra DCT block
140  FILL_BLOCK, ///< block is filled with single colour
141  INTER_BLOCK, ///< motion block with DCT applied to the difference
142  PATTERN_BLOCK, ///< block is filled with two colours following custom pattern
143  RAW_BLOCK, ///< uncoded 8x8 block
144 };
145 
146 /**
147  * Initialize length in all bundles.
148  *
149  * @param c decoder context
150  * @param width plane width
151  * @param bw plane width in 8x8 blocks
152  */
153 static void init_lengths(BinkContext *c, int width, int bw)
154 {
155  width = FFALIGN(width, 8);
156 
157  c->bundle[BINK_SRC_BLOCK_TYPES].len = av_log2((width >> 3) + 511) + 1;
158 
159  c->bundle[BINK_SRC_SUB_BLOCK_TYPES].len = av_log2((width >> 4) + 511) + 1;
160 
161  c->bundle[BINK_SRC_COLORS].len = av_log2(bw*64 + 511) + 1;
162 
166  c->bundle[BINK_SRC_Y_OFF].len = av_log2((width >> 3) + 511) + 1;
167 
168  c->bundle[BINK_SRC_PATTERN].len = av_log2((bw << 3) + 511) + 1;
169 
170  c->bundle[BINK_SRC_RUN].len = av_log2(bw*48 + 511) + 1;
171 }
172 
173 /**
174  * Allocate memory for bundles.
175  *
176  * @param c decoder context
177  */
179 {
180  int bw, bh, blocks;
181  int i;
182 
183  bw = (c->avctx->width + 7) >> 3;
184  bh = (c->avctx->height + 7) >> 3;
185  blocks = bw * bh;
186 
187  for (i = 0; i < BINKB_NB_SRC; i++) {
188  c->bundle[i].data = av_mallocz(blocks * 64);
189  if (!c->bundle[i].data)
190  return AVERROR(ENOMEM);
191  c->bundle[i].data_end = c->bundle[i].data + blocks * 64;
192  }
193 
194  return 0;
195 }
196 
197 /**
198  * Free memory used by bundles.
199  *
200  * @param c decoder context
201  */
203 {
204  int i;
205  for (i = 0; i < BINKB_NB_SRC; i++)
206  av_freep(&c->bundle[i].data);
207 }
208 
209 /**
210  * Merge two consequent lists of equal size depending on bits read.
211  *
212  * @param gb context for reading bits
213  * @param dst buffer where merged list will be written to
214  * @param src pointer to the head of the first list (the second lists starts at src+size)
215  * @param size input lists size
216  */
217 static void merge(GetBitContext *gb, uint8_t *dst, uint8_t *src, int size)
218 {
219  uint8_t *src2 = src + size;
220  int size2 = size;
221 
222  do {
223  if (!get_bits1(gb)) {
224  *dst++ = *src++;
225  size--;
226  } else {
227  *dst++ = *src2++;
228  size2--;
229  }
230  } while (size && size2);
231 
232  while (size--)
233  *dst++ = *src++;
234  while (size2--)
235  *dst++ = *src2++;
236 }
237 
238 /**
239  * Read information about Huffman tree used to decode data.
240  *
241  * @param gb context for reading bits
242  * @param tree pointer for storing tree data
243  */
244 static void read_tree(GetBitContext *gb, Tree *tree)
245 {
246  uint8_t tmp1[16] = { 0 }, tmp2[16], *in = tmp1, *out = tmp2;
247  int i, t, len;
248 
249  tree->vlc_num = get_bits(gb, 4);
250  if (!tree->vlc_num) {
251  for (i = 0; i < 16; i++)
252  tree->syms[i] = i;
253  return;
254  }
255  if (get_bits1(gb)) {
256  len = get_bits(gb, 3);
257  for (i = 0; i <= len; i++) {
258  tree->syms[i] = get_bits(gb, 4);
259  tmp1[tree->syms[i]] = 1;
260  }
261  for (i = 0; i < 16 && len < 16 - 1; i++)
262  if (!tmp1[i])
263  tree->syms[++len] = i;
264  } else {
265  len = get_bits(gb, 2);
266  for (i = 0; i < 16; i++)
267  in[i] = i;
268  for (i = 0; i <= len; i++) {
269  int size = 1 << i;
270  for (t = 0; t < 16; t += size << 1)
271  merge(gb, out + t, in + t, size);
272  FFSWAP(uint8_t*, in, out);
273  }
274  memcpy(tree->syms, in, 16);
275  }
276 }
277 
278 /**
279  * Prepare bundle for decoding data.
280  *
281  * @param gb context for reading bits
282  * @param c decoder context
283  * @param bundle_num number of the bundle to initialize
284  */
285 static void read_bundle(GetBitContext *gb, BinkContext *c, int bundle_num)
286 {
287  int i;
288 
289  if (bundle_num == BINK_SRC_COLORS) {
290  for (i = 0; i < 16; i++)
291  read_tree(gb, &c->col_high[i]);
292  c->col_lastval = 0;
293  }
294  if (bundle_num != BINK_SRC_INTRA_DC && bundle_num != BINK_SRC_INTER_DC)
295  read_tree(gb, &c->bundle[bundle_num].tree);
296  c->bundle[bundle_num].cur_dec =
297  c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data;
298 }
299 
300 /**
301  * common check before starting decoding bundle data
302  *
303  * @param gb context for reading bits
304  * @param b bundle
305  * @param t variable where number of elements to decode will be stored
306  */
307 #define CHECK_READ_VAL(gb, b, t) \
308  if (!b->cur_dec || (b->cur_dec > b->cur_ptr)) \
309  return 0; \
310  t = get_bits(gb, b->len); \
311  if (!t) { \
312  b->cur_dec = NULL; \
313  return 0; \
314  } \
315 
316 static int read_runs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
317 {
318  int t, v;
319  const uint8_t *dec_end;
320 
321  CHECK_READ_VAL(gb, b, t);
322  dec_end = b->cur_dec + t;
323  if (dec_end > b->data_end) {
324  av_log(avctx, AV_LOG_ERROR, "Run value went out of bounds\n");
325  return AVERROR_INVALIDDATA;
326  }
327  if (get_bits1(gb)) {
328  v = get_bits(gb, 4);
329  memset(b->cur_dec, v, t);
330  b->cur_dec += t;
331  } else {
332  while (b->cur_dec < dec_end)
333  *b->cur_dec++ = GET_HUFF(gb, b->tree);
334  }
335  return 0;
336 }
337 
339 {
340  int t, sign, v;
341  const uint8_t *dec_end;
342 
343  CHECK_READ_VAL(gb, b, t);
344  dec_end = b->cur_dec + t;
345  if (dec_end > b->data_end) {
346  av_log(avctx, AV_LOG_ERROR, "Too many motion values\n");
347  return AVERROR_INVALIDDATA;
348  }
349  if (get_bits1(gb)) {
350  v = get_bits(gb, 4);
351  if (v) {
352  sign = -get_bits1(gb);
353  v = (v ^ sign) - sign;
354  }
355  memset(b->cur_dec, v, t);
356  b->cur_dec += t;
357  } else {
358  while (b->cur_dec < dec_end) {
359  v = GET_HUFF(gb, b->tree);
360  if (v) {
361  sign = -get_bits1(gb);
362  v = (v ^ sign) - sign;
363  }
364  *b->cur_dec++ = v;
365  }
366  }
367  return 0;
368 }
369 
370 static const uint8_t bink_rlelens[4] = { 4, 8, 12, 32 };
371 
373 {
374  BinkContext * const c = avctx->priv_data;
375  int t, v;
376  int last = 0;
377  const uint8_t *dec_end;
378 
379  CHECK_READ_VAL(gb, b, t);
380  if (c->version == 'k') {
381  t ^= 0xBBu;
382  if (t == 0) {
383  b->cur_dec = NULL;
384  return 0;
385  }
386  }
387  dec_end = b->cur_dec + t;
388  if (dec_end > b->data_end) {
389  av_log(avctx, AV_LOG_ERROR, "Too many block type values\n");
390  return AVERROR_INVALIDDATA;
391  }
392  if (get_bits1(gb)) {
393  v = get_bits(gb, 4);
394  memset(b->cur_dec, v, t);
395  b->cur_dec += t;
396  } else {
397  while (b->cur_dec < dec_end) {
398  v = GET_HUFF(gb, b->tree);
399  if (v < 12) {
400  last = v;
401  *b->cur_dec++ = v;
402  } else {
403  int run = bink_rlelens[v - 12];
404 
405  if (dec_end - b->cur_dec < run)
406  return AVERROR_INVALIDDATA;
407  memset(b->cur_dec, last, run);
408  b->cur_dec += run;
409  }
410  }
411  }
412  return 0;
413 }
414 
416 {
417  int t, v;
418  const uint8_t *dec_end;
419 
420  CHECK_READ_VAL(gb, b, t);
421  dec_end = b->cur_dec + t;
422  if (dec_end > b->data_end) {
423  av_log(avctx, AV_LOG_ERROR, "Too many pattern values\n");
424  return AVERROR_INVALIDDATA;
425  }
426  while (b->cur_dec < dec_end) {
427  v = GET_HUFF(gb, b->tree);
428  v |= GET_HUFF(gb, b->tree) << 4;
429  *b->cur_dec++ = v;
430  }
431 
432  return 0;
433 }
434 
436 {
437  int t, sign, v;
438  const uint8_t *dec_end;
439 
440  CHECK_READ_VAL(gb, b, t);
441  dec_end = b->cur_dec + t;
442  if (dec_end > b->data_end) {
443  av_log(c->avctx, AV_LOG_ERROR, "Too many color values\n");
444  return AVERROR_INVALIDDATA;
445  }
446  if (get_bits1(gb)) {
447  c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]);
448  v = GET_HUFF(gb, b->tree);
449  v = (c->col_lastval << 4) | v;
450  if (c->version < 'i') {
451  sign = ((int8_t) v) >> 7;
452  v = ((v & 0x7F) ^ sign) - sign;
453  v += 0x80;
454  }
455  memset(b->cur_dec, v, t);
456  b->cur_dec += t;
457  } else {
458  while (b->cur_dec < dec_end) {
459  c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]);
460  v = GET_HUFF(gb, b->tree);
461  v = (c->col_lastval << 4) | v;
462  if (c->version < 'i') {
463  sign = ((int8_t) v) >> 7;
464  v = ((v & 0x7F) ^ sign) - sign;
465  v += 0x80;
466  }
467  *b->cur_dec++ = v;
468  }
469  }
470  return 0;
471 }
472 
473 /** number of bits used to store first DC value in bundle */
474 #define DC_START_BITS 11
475 
476 static int read_dcs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b,
477  int start_bits, int has_sign)
478 {
479  int i, j, len, len2, bsize, sign, v, v2;
480  int16_t *dst = (int16_t*)b->cur_dec;
481  int16_t *dst_end = (int16_t*)b->data_end;
482 
483  CHECK_READ_VAL(gb, b, len);
484  v = get_bits(gb, start_bits - has_sign);
485  if (v && has_sign) {
486  sign = -get_bits1(gb);
487  v = (v ^ sign) - sign;
488  }
489  if (dst_end - dst < 1)
490  return AVERROR_INVALIDDATA;
491  *dst++ = v;
492  len--;
493  for (i = 0; i < len; i += 8) {
494  len2 = FFMIN(len - i, 8);
495  if (dst_end - dst < len2)
496  return AVERROR_INVALIDDATA;
497  bsize = get_bits(gb, 4);
498  if (bsize) {
499  for (j = 0; j < len2; j++) {
500  v2 = get_bits(gb, bsize);
501  if (v2) {
502  sign = -get_bits1(gb);
503  v2 = (v2 ^ sign) - sign;
504  }
505  v += v2;
506  *dst++ = v;
507  if (v < -32768 || v > 32767) {
508  av_log(avctx, AV_LOG_ERROR, "DC value went out of bounds: %d\n", v);
509  return AVERROR_INVALIDDATA;
510  }
511  }
512  } else {
513  for (j = 0; j < len2; j++)
514  *dst++ = v;
515  }
516  }
517 
518  b->cur_dec = (uint8_t*)dst;
519  return 0;
520 }
521 
522 /**
523  * Retrieve next value from bundle.
524  *
525  * @param c decoder context
526  * @param bundle bundle number
527  */
528 static inline int get_value(BinkContext *c, int bundle)
529 {
530  int ret;
531 
532  if (bundle < BINK_SRC_X_OFF || bundle == BINK_SRC_RUN)
533  return *c->bundle[bundle].cur_ptr++;
534  if (bundle == BINK_SRC_X_OFF || bundle == BINK_SRC_Y_OFF)
535  return (int8_t)*c->bundle[bundle].cur_ptr++;
536  ret = *(int16_t*)c->bundle[bundle].cur_ptr;
537  c->bundle[bundle].cur_ptr += 2;
538  return ret;
539 }
540 
541 static av_cold void binkb_init_bundle(BinkContext *c, int bundle_num)
542 {
543  c->bundle[bundle_num].cur_dec =
544  c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data;
545  c->bundle[bundle_num].len = 13;
546 }
547 
549 {
550  int i;
551  for (i = 0; i < BINKB_NB_SRC; i++)
552  binkb_init_bundle(c, i);
553 }
554 
555 static int binkb_read_bundle(BinkContext *c, GetBitContext *gb, int bundle_num)
556 {
557  const int bits = binkb_bundle_sizes[bundle_num];
558  const int mask = 1 << (bits - 1);
559  const int issigned = binkb_bundle_signed[bundle_num];
560  Bundle *b = &c->bundle[bundle_num];
561  int i, len;
562 
563  CHECK_READ_VAL(gb, b, len);
564  if (b->data_end - b->cur_dec < len * (1 + (bits > 8)))
565  return AVERROR_INVALIDDATA;
566  if (bits <= 8) {
567  if (!issigned) {
568  for (i = 0; i < len; i++)
569  *b->cur_dec++ = get_bits(gb, bits);
570  } else {
571  for (i = 0; i < len; i++)
572  *b->cur_dec++ = get_bits(gb, bits) - mask;
573  }
574  } else {
575  int16_t *dst = (int16_t*)b->cur_dec;
576 
577  if (!issigned) {
578  for (i = 0; i < len; i++)
579  *dst++ = get_bits(gb, bits);
580  } else {
581  for (i = 0; i < len; i++)
582  *dst++ = get_bits(gb, bits) - mask;
583  }
584  b->cur_dec = (uint8_t*)dst;
585  }
586  return 0;
587 }
588 
589 static inline int binkb_get_value(BinkContext *c, int bundle_num)
590 {
591  int16_t ret;
592  const int bits = binkb_bundle_sizes[bundle_num];
593 
594  if (bits <= 8) {
595  int val = *c->bundle[bundle_num].cur_ptr++;
596  return binkb_bundle_signed[bundle_num] ? (int8_t)val : val;
597  }
598  ret = *(int16_t*)c->bundle[bundle_num].cur_ptr;
599  c->bundle[bundle_num].cur_ptr += 2;
600  return ret;
601 }
602 
603 /**
604  * Read 8x8 block of DCT coefficients.
605  *
606  * @param gb context for reading bits
607  * @param block place for storing coefficients
608  * @param scan scan order table
609  * @param quant_matrices quantization matrices
610  * @return 0 for success, negative value in other cases
611  */
613  const uint8_t *scan, int *coef_count_,
614  int coef_idx[64], int q)
615 {
616  int coef_list[128];
617  int mode_list[128];
618  int i, t, bits, ccoef, mode, sign;
619  int list_start = 64, list_end = 64, list_pos;
620  int coef_count = 0;
621  int quant_idx;
622 
623  coef_list[list_end] = 4; mode_list[list_end++] = 0;
624  coef_list[list_end] = 24; mode_list[list_end++] = 0;
625  coef_list[list_end] = 44; mode_list[list_end++] = 0;
626  coef_list[list_end] = 1; mode_list[list_end++] = 3;
627  coef_list[list_end] = 2; mode_list[list_end++] = 3;
628  coef_list[list_end] = 3; mode_list[list_end++] = 3;
629 
630  for (bits = get_bits(gb, 4) - 1; bits >= 0; bits--) {
631  list_pos = list_start;
632  while (list_pos < list_end) {
633  if (!(mode_list[list_pos] | coef_list[list_pos]) || !get_bits1(gb)) {
634  list_pos++;
635  continue;
636  }
637  ccoef = coef_list[list_pos];
638  mode = mode_list[list_pos];
639  switch (mode) {
640  case 0:
641  coef_list[list_pos] = ccoef + 4;
642  mode_list[list_pos] = 1;
643  case 2:
644  if (mode == 2) {
645  coef_list[list_pos] = 0;
646  mode_list[list_pos++] = 0;
647  }
648  for (i = 0; i < 4; i++, ccoef++) {
649  if (get_bits1(gb)) {
650  coef_list[--list_start] = ccoef;
651  mode_list[ list_start] = 3;
652  } else {
653  if (!bits) {
654  t = 1 - (get_bits1(gb) << 1);
655  } else {
656  t = get_bits(gb, bits) | 1 << bits;
657  sign = -get_bits1(gb);
658  t = (t ^ sign) - sign;
659  }
660  block[scan[ccoef]] = t;
661  coef_idx[coef_count++] = ccoef;
662  }
663  }
664  break;
665  case 1:
666  mode_list[list_pos] = 2;
667  for (i = 0; i < 3; i++) {
668  ccoef += 4;
669  coef_list[list_end] = ccoef;
670  mode_list[list_end++] = 2;
671  }
672  break;
673  case 3:
674  if (!bits) {
675  t = 1 - (get_bits1(gb) << 1);
676  } else {
677  t = get_bits(gb, bits) | 1 << bits;
678  sign = -get_bits1(gb);
679  t = (t ^ sign) - sign;
680  }
681  block[scan[ccoef]] = t;
682  coef_idx[coef_count++] = ccoef;
683  coef_list[list_pos] = 0;
684  mode_list[list_pos++] = 0;
685  break;
686  }
687  }
688  }
689 
690  if (q == -1) {
691  quant_idx = get_bits(gb, 4);
692  } else {
693  quant_idx = q;
694  if (quant_idx > 15U) {
695  av_log(c->avctx, AV_LOG_ERROR, "quant_index %d out of range\n", quant_idx);
696  return AVERROR_INVALIDDATA;
697  }
698  }
699 
700  *coef_count_ = coef_count;
701 
702  return quant_idx;
703 }
704 
705 static void unquantize_dct_coeffs(int32_t block[64], const int32_t quant[64],
706  int coef_count, int coef_idx[64],
707  const uint8_t *scan)
708 {
709  int i;
710  block[0] = (block[0] * quant[0]) >> 11;
711  for (i = 0; i < coef_count; i++) {
712  int idx = coef_idx[i];
713  block[scan[idx]] = (block[scan[idx]] * quant[idx]) >> 11;
714  }
715 }
716 
717 /**
718  * Read 8x8 block with residue after motion compensation.
719  *
720  * @param gb context for reading bits
721  * @param block place to store read data
722  * @param masks_count number of masks to decode
723  * @return 0 on success, negative value in other cases
724  */
725 static int read_residue(GetBitContext *gb, int16_t block[64], int masks_count)
726 {
727  int coef_list[128];
728  int mode_list[128];
729  int i, sign, mask, ccoef, mode;
730  int list_start = 64, list_end = 64, list_pos;
731  int nz_coeff[64];
732  int nz_coeff_count = 0;
733 
734  coef_list[list_end] = 4; mode_list[list_end++] = 0;
735  coef_list[list_end] = 24; mode_list[list_end++] = 0;
736  coef_list[list_end] = 44; mode_list[list_end++] = 0;
737  coef_list[list_end] = 0; mode_list[list_end++] = 2;
738 
739  for (mask = 1 << get_bits(gb, 3); mask; mask >>= 1) {
740  for (i = 0; i < nz_coeff_count; i++) {
741  if (!get_bits1(gb))
742  continue;
743  if (block[nz_coeff[i]] < 0)
744  block[nz_coeff[i]] -= mask;
745  else
746  block[nz_coeff[i]] += mask;
747  masks_count--;
748  if (masks_count < 0)
749  return 0;
750  }
751  list_pos = list_start;
752  while (list_pos < list_end) {
753  if (!(coef_list[list_pos] | mode_list[list_pos]) || !get_bits1(gb)) {
754  list_pos++;
755  continue;
756  }
757  ccoef = coef_list[list_pos];
758  mode = mode_list[list_pos];
759  switch (mode) {
760  case 0:
761  coef_list[list_pos] = ccoef + 4;
762  mode_list[list_pos] = 1;
763  case 2:
764  if (mode == 2) {
765  coef_list[list_pos] = 0;
766  mode_list[list_pos++] = 0;
767  }
768  for (i = 0; i < 4; i++, ccoef++) {
769  if (get_bits1(gb)) {
770  coef_list[--list_start] = ccoef;
771  mode_list[ list_start] = 3;
772  } else {
773  nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
774  sign = -get_bits1(gb);
775  block[bink_scan[ccoef]] = (mask ^ sign) - sign;
776  masks_count--;
777  if (masks_count < 0)
778  return 0;
779  }
780  }
781  break;
782  case 1:
783  mode_list[list_pos] = 2;
784  for (i = 0; i < 3; i++) {
785  ccoef += 4;
786  coef_list[list_end] = ccoef;
787  mode_list[list_end++] = 2;
788  }
789  break;
790  case 3:
791  nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
792  sign = -get_bits1(gb);
793  block[bink_scan[ccoef]] = (mask ^ sign) - sign;
794  coef_list[list_pos] = 0;
795  mode_list[list_pos++] = 0;
796  masks_count--;
797  if (masks_count < 0)
798  return 0;
799  break;
800  }
801  }
802  }
803 
804  return 0;
805 }
806 
807 /**
808  * Copy 8x8 block from source to destination, where src and dst may be overlapped
809  */
810 static inline void put_pixels8x8_overlapped(uint8_t *dst, uint8_t *src, int stride)
811 {
812  uint8_t tmp[64];
813  int i;
814  for (i = 0; i < 8; i++)
815  memcpy(tmp + i*8, src + i*stride, 8);
816  for (i = 0; i < 8; i++)
817  memcpy(dst + i*stride, tmp + i*8, 8);
818 }
819 
821  int plane_idx, int is_key, int is_chroma)
822 {
823  int blk, ret;
824  int i, j, bx, by;
825  uint8_t *dst, *ref, *ref_start, *ref_end;
826  int v, col[2];
827  const uint8_t *scan;
828  int xoff, yoff;
829  LOCAL_ALIGNED_32(int16_t, block, [64]);
830  LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
831  int coordmap[64];
832  int ybias = is_key ? -15 : 0;
833  int qp, quant_idx, coef_count, coef_idx[64];
834 
835  const int stride = frame->linesize[plane_idx];
836  int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3;
837  int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
838 
840  ref_start = frame->data[plane_idx];
841  ref_end = frame->data[plane_idx] + (bh * frame->linesize[plane_idx] + bw) * 8;
842 
843  for (i = 0; i < 64; i++)
844  coordmap[i] = (i & 7) + (i >> 3) * stride;
845 
846  for (by = 0; by < bh; by++) {
847  for (i = 0; i < BINKB_NB_SRC; i++) {
848  if ((ret = binkb_read_bundle(c, gb, i)) < 0)
849  return ret;
850  }
851 
852  dst = frame->data[plane_idx] + 8*by*stride;
853  for (bx = 0; bx < bw; bx++, dst += 8) {
855  switch (blk) {
856  case 0:
857  break;
858  case 1:
859  scan = bink_patterns[get_bits(gb, 4)];
860  i = 0;
861  do {
862  int mode, run;
863 
864  mode = get_bits1(gb);
865  run = get_bits(gb, binkb_runbits[i]) + 1;
866 
867  i += run;
868  if (i > 64) {
869  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
870  return AVERROR_INVALIDDATA;
871  }
872  if (mode) {
874  for (j = 0; j < run; j++)
875  dst[coordmap[*scan++]] = v;
876  } else {
877  for (j = 0; j < run; j++)
878  dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
879  }
880  } while (i < 63);
881  if (i == 63)
882  dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
883  break;
884  case 2:
885  memset(dctblock, 0, sizeof(*dctblock) * 64);
886  dctblock[0] = binkb_get_value(c, BINKB_SRC_INTRA_DC);
888  if ((quant_idx = read_dct_coeffs(c, gb, dctblock, bink_scan, &coef_count, coef_idx, qp)) < 0)
889  return quant_idx;
890  unquantize_dct_coeffs(dctblock, binkb_intra_quant[quant_idx], coef_count, coef_idx, bink_scan);
891  c->binkdsp.idct_put(dst, stride, dctblock);
892  break;
893  case 3:
894  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
895  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
896  ref = dst + xoff + yoff * stride;
897  if (ref < ref_start || ref + 8*stride > ref_end) {
898  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
899  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
900  c->hdsp.put_pixels_tab[1][0](dst, ref, stride, 8);
901  } else {
902  put_pixels8x8_overlapped(dst, ref, stride);
903  }
904  c->bdsp.clear_block(block);
906  read_residue(gb, block, v);
907  c->binkdsp.add_pixels8(dst, block, stride);
908  break;
909  case 4:
910  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
911  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
912  ref = dst + xoff + yoff * stride;
913  if (ref < ref_start || ref + 8 * stride > ref_end) {
914  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
915  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
916  c->hdsp.put_pixels_tab[1][0](dst, ref, stride, 8);
917  } else {
918  put_pixels8x8_overlapped(dst, ref, stride);
919  }
920  memset(dctblock, 0, sizeof(*dctblock) * 64);
921  dctblock[0] = binkb_get_value(c, BINKB_SRC_INTER_DC);
923  if ((quant_idx = read_dct_coeffs(c, gb, dctblock, bink_scan, &coef_count, coef_idx, qp)) < 0)
924  return quant_idx;
925  unquantize_dct_coeffs(dctblock, binkb_inter_quant[quant_idx], coef_count, coef_idx, bink_scan);
926  c->binkdsp.idct_add(dst, stride, dctblock);
927  break;
928  case 5:
930  c->bdsp.fill_block_tab[1](dst, v, stride, 8);
931  break;
932  case 6:
933  for (i = 0; i < 2; i++)
934  col[i] = binkb_get_value(c, BINKB_SRC_COLORS);
935  for (i = 0; i < 8; i++) {
937  for (j = 0; j < 8; j++, v >>= 1)
938  dst[i*stride + j] = col[v & 1];
939  }
940  break;
941  case 7:
942  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
943  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
944  ref = dst + xoff + yoff * stride;
945  if (ref < ref_start || ref + 8 * stride > ref_end) {
946  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
947  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
948  c->hdsp.put_pixels_tab[1][0](dst, ref, stride, 8);
949  } else {
950  put_pixels8x8_overlapped(dst, ref, stride);
951  }
952  break;
953  case 8:
954  for (i = 0; i < 8; i++)
955  memcpy(dst + i*stride, c->bundle[BINKB_SRC_COLORS].cur_ptr + i*8, 8);
956  c->bundle[BINKB_SRC_COLORS].cur_ptr += 64;
957  break;
958  default:
959  av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
960  return AVERROR_INVALIDDATA;
961  }
962  }
963  }
964  if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary
965  skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
966 
967  return 0;
968 }
969 
971  uint8_t *dst, uint8_t *prev, int stride,
972  uint8_t *ref_start,
973  uint8_t *ref_end)
974 {
975  int xoff = get_value(c, BINK_SRC_X_OFF);
976  int yoff = get_value(c, BINK_SRC_Y_OFF);
977  uint8_t *ref = prev + xoff + yoff * stride;
978  if (ref < ref_start || ref > ref_end) {
979  av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
980  xoff, yoff);
981  return AVERROR_INVALIDDATA;
982  }
983  c->hdsp.put_pixels_tab[1][0](dst, ref, stride, 8);
984 
985  return 0;
986 }
987 
989  int plane_idx, int is_chroma)
990 {
991  int blk, ret;
992  int i, j, bx, by;
993  uint8_t *dst, *prev, *ref_start, *ref_end;
994  int v, col[2];
995  const uint8_t *scan;
996  LOCAL_ALIGNED_32(int16_t, block, [64]);
997  LOCAL_ALIGNED_16(uint8_t, ublock, [64]);
998  LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
999  int coordmap[64], quant_idx, coef_count, coef_idx[64];
1000 
1001  const int stride = frame->linesize[plane_idx];
1002  int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3;
1003  int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
1004  int width = c->avctx->width >> is_chroma;
1005  int height = c->avctx->height >> is_chroma;
1006 
1007  if (c->version == 'k' && get_bits1(gb)) {
1008  int fill = get_bits(gb, 8);
1009 
1010  dst = frame->data[plane_idx];
1011 
1012  for (i = 0; i < height; i++)
1013  memset(dst + i * stride, fill, width);
1014  goto end;
1015  }
1016 
1017  init_lengths(c, FFMAX(width, 8), bw);
1018  for (i = 0; i < BINK_NB_SRC; i++)
1019  read_bundle(gb, c, i);
1020 
1021  ref_start = c->last->data[plane_idx] ? c->last->data[plane_idx]
1022  : frame->data[plane_idx];
1023  ref_end = ref_start
1024  + (bw - 1 + c->last->linesize[plane_idx] * (bh - 1)) * 8;
1025 
1026  for (i = 0; i < 64; i++)
1027  coordmap[i] = (i & 7) + (i >> 3) * stride;
1028 
1029  for (by = 0; by < bh; by++) {
1030  if ((ret = read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_BLOCK_TYPES])) < 0)
1031  return ret;
1032  if ((ret = read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_SUB_BLOCK_TYPES])) < 0)
1033  return ret;
1034  if ((ret = read_colors(gb, &c->bundle[BINK_SRC_COLORS], c)) < 0)
1035  return ret;
1036  if ((ret = read_patterns(c->avctx, gb, &c->bundle[BINK_SRC_PATTERN])) < 0)
1037  return ret;
1038  if ((ret = read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_X_OFF])) < 0)
1039  return ret;
1040  if ((ret = read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_Y_OFF])) < 0)
1041  return ret;
1042  if ((ret = read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0)) < 0)
1043  return ret;
1044  if ((ret = read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1)) < 0)
1045  return ret;
1046  if ((ret = read_runs(c->avctx, gb, &c->bundle[BINK_SRC_RUN])) < 0)
1047  return ret;
1048 
1049  if (by == bh)
1050  break;
1051  dst = frame->data[plane_idx] + 8*by*stride;
1052  prev = (c->last->data[plane_idx] ? c->last->data[plane_idx]
1053  : frame->data[plane_idx]) + 8*by*stride;
1054  for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) {
1055  blk = get_value(c, BINK_SRC_BLOCK_TYPES);
1056  // 16x16 block type on odd line means part of the already decoded block, so skip it
1057  if ((by & 1) && blk == SCALED_BLOCK) {
1058  bx++;
1059  dst += 8;
1060  prev += 8;
1061  continue;
1062  }
1063  switch (blk) {
1064  case SKIP_BLOCK:
1065  c->hdsp.put_pixels_tab[1][0](dst, prev, stride, 8);
1066  break;
1067  case SCALED_BLOCK:
1069  switch (blk) {
1070  case RUN_BLOCK:
1071  scan = bink_patterns[get_bits(gb, 4)];
1072  i = 0;
1073  do {
1074  int run = get_value(c, BINK_SRC_RUN) + 1;
1075 
1076  i += run;
1077  if (i > 64) {
1078  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
1079  return AVERROR_INVALIDDATA;
1080  }
1081  if (get_bits1(gb)) {
1082  v = get_value(c, BINK_SRC_COLORS);
1083  for (j = 0; j < run; j++)
1084  ublock[*scan++] = v;
1085  } else {
1086  for (j = 0; j < run; j++)
1087  ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
1088  }
1089  } while (i < 63);
1090  if (i == 63)
1091  ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
1092  break;
1093  case INTRA_BLOCK:
1094  memset(dctblock, 0, sizeof(*dctblock) * 64);
1095  dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
1096  if ((quant_idx = read_dct_coeffs(c, gb, dctblock, bink_scan, &coef_count, coef_idx, -1)) < 0)
1097  return quant_idx;
1098  unquantize_dct_coeffs(dctblock, bink_intra_quant[quant_idx], coef_count, coef_idx, bink_scan);
1099  c->binkdsp.idct_put(ublock, 8, dctblock);
1100  break;
1101  case FILL_BLOCK:
1102  v = get_value(c, BINK_SRC_COLORS);
1103  c->bdsp.fill_block_tab[0](dst, v, stride, 16);
1104  break;
1105  case PATTERN_BLOCK:
1106  for (i = 0; i < 2; i++)
1107  col[i] = get_value(c, BINK_SRC_COLORS);
1108  for (j = 0; j < 8; j++) {
1109  v = get_value(c, BINK_SRC_PATTERN);
1110  for (i = 0; i < 8; i++, v >>= 1)
1111  ublock[i + j*8] = col[v & 1];
1112  }
1113  break;
1114  case RAW_BLOCK:
1115  for (j = 0; j < 8; j++)
1116  for (i = 0; i < 8; i++)
1117  ublock[i + j*8] = get_value(c, BINK_SRC_COLORS);
1118  break;
1119  default:
1120  av_log(c->avctx, AV_LOG_ERROR, "Incorrect 16x16 block type %d\n", blk);
1121  return AVERROR_INVALIDDATA;
1122  }
1123  if (blk != FILL_BLOCK)
1124  c->binkdsp.scale_block(ublock, dst, stride);
1125  bx++;
1126  dst += 8;
1127  prev += 8;
1128  break;
1129  case MOTION_BLOCK:
1130  ret = bink_put_pixels(c, dst, prev, stride,
1131  ref_start, ref_end);
1132  if (ret < 0)
1133  return ret;
1134  break;
1135  case RUN_BLOCK:
1136  scan = bink_patterns[get_bits(gb, 4)];
1137  i = 0;
1138  do {
1139  int run = get_value(c, BINK_SRC_RUN) + 1;
1140 
1141  i += run;
1142  if (i > 64) {
1143  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
1144  return AVERROR_INVALIDDATA;
1145  }
1146  if (get_bits1(gb)) {
1147  v = get_value(c, BINK_SRC_COLORS);
1148  for (j = 0; j < run; j++)
1149  dst[coordmap[*scan++]] = v;
1150  } else {
1151  for (j = 0; j < run; j++)
1152  dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
1153  }
1154  } while (i < 63);
1155  if (i == 63)
1156  dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
1157  break;
1158  case RESIDUE_BLOCK:
1159  ret = bink_put_pixels(c, dst, prev, stride,
1160  ref_start, ref_end);
1161  if (ret < 0)
1162  return ret;
1163  c->bdsp.clear_block(block);
1164  v = get_bits(gb, 7);
1165  read_residue(gb, block, v);
1166  c->binkdsp.add_pixels8(dst, block, stride);
1167  break;
1168  case INTRA_BLOCK:
1169  memset(dctblock, 0, sizeof(*dctblock) * 64);
1170  dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
1171  if ((quant_idx = read_dct_coeffs(c, gb, dctblock, bink_scan, &coef_count, coef_idx, -1)) < 0)
1172  return quant_idx;
1173  unquantize_dct_coeffs(dctblock, bink_intra_quant[quant_idx], coef_count, coef_idx, bink_scan);
1174  c->binkdsp.idct_put(dst, stride, dctblock);
1175  break;
1176  case FILL_BLOCK:
1177  v = get_value(c, BINK_SRC_COLORS);
1178  c->bdsp.fill_block_tab[1](dst, v, stride, 8);
1179  break;
1180  case INTER_BLOCK:
1181  ret = bink_put_pixels(c, dst, prev, stride,
1182  ref_start, ref_end);
1183  if (ret < 0)
1184  return ret;
1185  memset(dctblock, 0, sizeof(*dctblock) * 64);
1186  dctblock[0] = get_value(c, BINK_SRC_INTER_DC);
1187  if ((quant_idx = read_dct_coeffs(c, gb, dctblock, bink_scan, &coef_count, coef_idx, -1)) < 0)
1188  return quant_idx;
1189  unquantize_dct_coeffs(dctblock, bink_inter_quant[quant_idx], coef_count, coef_idx, bink_scan);
1190  c->binkdsp.idct_add(dst, stride, dctblock);
1191  break;
1192  case PATTERN_BLOCK:
1193  for (i = 0; i < 2; i++)
1194  col[i] = get_value(c, BINK_SRC_COLORS);
1195  for (i = 0; i < 8; i++) {
1196  v = get_value(c, BINK_SRC_PATTERN);
1197  for (j = 0; j < 8; j++, v >>= 1)
1198  dst[i*stride + j] = col[v & 1];
1199  }
1200  break;
1201  case RAW_BLOCK:
1202  for (i = 0; i < 8; i++)
1203  memcpy(dst + i*stride, c->bundle[BINK_SRC_COLORS].cur_ptr + i*8, 8);
1204  c->bundle[BINK_SRC_COLORS].cur_ptr += 64;
1205  break;
1206  default:
1207  av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
1208  return AVERROR_INVALIDDATA;
1209  }
1210  }
1211  }
1212 
1213 end:
1214  if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary
1215  skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
1216 
1217  return 0;
1218 }
1219 
1220 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
1221 {
1222  BinkContext * const c = avctx->priv_data;
1223  AVFrame *frame = data;
1224  GetBitContext gb;
1225  int plane, plane_idx, ret;
1226  int bits_count = pkt->size << 3;
1227 
1228  if (c->version > 'b') {
1229  if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
1230  return ret;
1231  } else {
1232  if ((ret = ff_reget_buffer(avctx, c->last)) < 0)
1233  return ret;
1234  if ((ret = av_frame_ref(frame, c->last)) < 0)
1235  return ret;
1236  }
1237 
1238  init_get_bits(&gb, pkt->data, bits_count);
1239  if (c->has_alpha) {
1240  if (c->version >= 'i')
1241  skip_bits_long(&gb, 32);
1242  if ((ret = bink_decode_plane(c, frame, &gb, 3, 0)) < 0)
1243  return ret;
1244  }
1245  if (c->version >= 'i')
1246  skip_bits_long(&gb, 32);
1247 
1248  c->frame_num++;
1249 
1250  for (plane = 0; plane < 3; plane++) {
1251  plane_idx = (!plane || !c->swap_planes) ? plane : (plane ^ 3);
1252 
1253  if (c->version > 'b') {
1254  if ((ret = bink_decode_plane(c, frame, &gb, plane_idx, !!plane)) < 0)
1255  return ret;
1256  } else {
1257  if ((ret = binkb_decode_plane(c, frame, &gb, plane_idx,
1258  c->frame_num == 1, !!plane)) < 0)
1259  return ret;
1260  }
1261  if (get_bits_count(&gb) >= bits_count)
1262  break;
1263  }
1264  emms_c();
1265 
1266  if (c->version > 'b') {
1267  av_frame_unref(c->last);
1268  if ((ret = av_frame_ref(c->last, frame)) < 0)
1269  return ret;
1270  }
1271 
1272  *got_frame = 1;
1273 
1274  /* always report that the buffer was completely consumed */
1275  return pkt->size;
1276 }
1277 
1278 /**
1279  * Calculate quantization tables for version b
1280  */
1281 static av_cold void binkb_calc_quant(void)
1282 {
1283  uint8_t inv_bink_scan[64];
1284  static const int s[64]={
1285  1073741824,1489322693,1402911301,1262586814,1073741824, 843633538, 581104888, 296244703,
1286  1489322693,2065749918,1945893874,1751258219,1489322693,1170153332, 806015634, 410903207,
1287  1402911301,1945893874,1832991949,1649649171,1402911301,1102260336, 759250125, 387062357,
1288  1262586814,1751258219,1649649171,1484645031,1262586814, 992008094, 683307060, 348346918,
1289  1073741824,1489322693,1402911301,1262586814,1073741824, 843633538, 581104888, 296244703,
1290  843633538,1170153332,1102260336, 992008094, 843633538, 662838617, 456571181, 232757969,
1291  581104888, 806015634, 759250125, 683307060, 581104888, 456571181, 314491699, 160326478,
1292  296244703, 410903207, 387062357, 348346918, 296244703, 232757969, 160326478, 81733730,
1293  };
1294  int i, j;
1295 #define C (1LL<<30)
1296  for (i = 0; i < 64; i++)
1297  inv_bink_scan[bink_scan[i]] = i;
1298 
1299  for (j = 0; j < 16; j++) {
1300  for (i = 0; i < 64; i++) {
1301  int k = inv_bink_scan[i];
1302  binkb_intra_quant[j][k] = binkb_intra_seed[i] * (int64_t)s[i] *
1303  binkb_num[j]/(binkb_den[j] * (C>>12));
1304  binkb_inter_quant[j][k] = binkb_inter_seed[i] * (int64_t)s[i] *
1305  binkb_num[j]/(binkb_den[j] * (C>>12));
1306  }
1307  }
1308 }
1309 
1311 {
1312  BinkContext * const c = avctx->priv_data;
1313  static VLC_TYPE table[16 * 128][2];
1314  static int binkb_initialised = 0;
1315  int i, ret;
1316  int flags;
1317 
1318  c->version = avctx->codec_tag >> 24;
1319  if (avctx->extradata_size < 4) {
1320  av_log(avctx, AV_LOG_ERROR, "Extradata missing or too short\n");
1321  return AVERROR_INVALIDDATA;
1322  }
1323  flags = AV_RL32(avctx->extradata);
1324  c->has_alpha = flags & BINK_FLAG_ALPHA;
1325  c->swap_planes = c->version >= 'h';
1326  if (!bink_trees[15].table) {
1327  for (i = 0; i < 16; i++) {
1328  const int maxbits = bink_tree_lens[i][15];
1329  bink_trees[i].table = table + i*128;
1330  bink_trees[i].table_allocated = 1 << maxbits;
1331  init_vlc(&bink_trees[i], maxbits, 16,
1332  bink_tree_lens[i], 1, 1,
1334  }
1335  }
1336  c->avctx = avctx;
1337 
1338  c->last = av_frame_alloc();
1339  if (!c->last)
1340  return AVERROR(ENOMEM);
1341 
1342  if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
1343  return ret;
1344 
1346  avctx->color_range = c->version == 'k' ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
1347 
1348  ff_blockdsp_init(&c->bdsp, avctx);
1349  ff_hpeldsp_init(&c->hdsp, avctx->flags);
1350  ff_binkdsp_init(&c->binkdsp);
1351 
1352  if ((ret = init_bundles(c)) < 0) {
1353  free_bundles(c);
1354  return ret;
1355  }
1356 
1357  if (c->version == 'b') {
1358  if (!binkb_initialised) {
1359  binkb_calc_quant();
1360  binkb_initialised = 1;
1361  }
1362  }
1363 
1364  return 0;
1365 }
1366 
1368 {
1369  BinkContext * const c = avctx->priv_data;
1370 
1371  av_frame_free(&c->last);
1372 
1373  free_bundles(c);
1374  return 0;
1375 }
1376 
1377 static void flush(AVCodecContext *avctx)
1378 {
1379  BinkContext * const c = avctx->priv_data;
1380 
1381  c->frame_num = 0;
1382 }
1383 
1385  .name = "binkvideo",
1386  .long_name = NULL_IF_CONFIG_SMALL("Bink video"),
1387  .type = AVMEDIA_TYPE_VIDEO,
1388  .id = AV_CODEC_ID_BINKVIDEO,
1389  .priv_data_size = sizeof(BinkContext),
1390  .init = decode_init,
1391  .close = decode_end,
1392  .decode = decode_frame,
1393  .flush = flush,
1394  .capabilities = AV_CODEC_CAP_DR1,
1395 };
int plane
Definition: avisynth_c.h:422
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static const uint8_t bink_tree_lens[16][16]
Definition: binkdata.h:106
8-bit values for 2-colour pattern fill
Definition: bink.c:48
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
av_cold void ff_binkdsp_init(BinkDSPContext *c)
Definition: binkdsp.c:151
static const uint8_t bink_tree_bits[16][16]
Definition: binkdata.h:39
#define C
#define CHECK_READ_VAL(gb, b, t)
common check before starting decoding bundle data
Definition: bink.c:307
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:381
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:293
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:36
void(* scale_block)(const uint8_t src[64], uint8_t *dst, int linesize)
Definition: binkdsp.h:37
static const uint8_t binkb_den[16]
Definition: binkdata.h:651
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2187
static int read_residue(GetBitContext *gb, int16_t block[64], int masks_count)
Read 8x8 block with residue after motion compensation.
Definition: bink.c:725
int size
Definition: avcodec.h:1469
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
int av_log2(unsigned v)
Definition: intmath.c:26
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1766
8-bit values for 2-colour pattern fill
Definition: bink.c:78
static const uint8_t bink_scan[64]
Bink DCT and residue 8x8 block scan order.
Definition: binkdata.h:28
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
uint8_t run
Definition: svq3.c:206
static AVPacket pkt
#define blk(i)
Definition: sha.c:185
8x8 block types
Definition: bink.c:75
#define src
Definition: vp8dsp.c:254
Tree col_high[16]
trees for decoding high nibble in "colours" data type
Definition: bink.c:126
AVCodec.
Definition: avcodec.h:3468
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
16x16 block types (a subset of 8x8 block types)
Definition: bink.c:76
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: decode.c:1966
int len
length of number of entries to decode (in bits)
Definition: bink.c:103
Macro definitions for various function/variable attributes.
HpelDSPContext hdsp
Definition: bink.c:117
static int32_t binkb_inter_quant[16][64]
Definition: bink.c:69
void(* idct_put)(uint8_t *dest, int line_size, int32_t *block)
Definition: binkdsp.h:35
quantizer values for interblocks with DCT
Definition: bink.c:54
static av_cold void binkb_init_bundle(BinkContext *c, int bundle_num)
Definition: bink.c:541
static int read_patterns(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
Definition: bink.c:415
X components of motion value.
Definition: bink.c:49
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
motion block with DCT applied to the difference
Definition: bink.c:141
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:82
intra DCT block
Definition: bink.c:139
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
static int binkb_get_value(BinkContext *c, int bundle_num)
Definition: bink.c:589
static void put_pixels8x8_overlapped(uint8_t *dst, uint8_t *src, int stride)
Copy 8x8 block from source to destination, where src and dst may be overlapped.
Definition: bink.c:810
Tree tree
Huffman tree-related data.
Definition: bink.c:104
BlockTypes
Bink video block types.
Definition: bink.c:133
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
uncoded 8x8 block
Definition: bink.c:143
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1657
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:253
static void unquantize_dct_coeffs(int32_t block[64], const int32_t quant[64], int coef_count, int coef_idx[64], const uint8_t *scan)
Definition: bink.c:705
#define height
uint8_t * data
Definition: avcodec.h:1468
static const int32_t bink_inter_quant[16][64]
Definition: binkdata.h:451
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
int vlc_num
tree number (in bink_trees[])
Definition: bink.c:92
skipped block
Definition: bink.c:134
bitstream reader API header.
static int read_runs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
Definition: bink.c:316
ptrdiff_t size
Definition: opengl_enc.c:101
data structure used for decoding single Bink data type
Definition: bink.c:102
#define FFALIGN(x, a)
Definition: macros.h:48
static const uint8_t bink_patterns[16][64]
Definition: binkdata.h:125
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:201
uint8_t * data
buffer for decoded symbols
Definition: bink.c:105
Bink DSP routines.
#define U(x)
Definition: vp56_arith.h:37
block is copied from previous frame with some offset
Definition: bink.c:136
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
uint8_t * data_end
buffer end
Definition: bink.c:106
static const uint16_t mask[17]
Definition: lzw.c:38
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
unsigned frame_num
Definition: bink.c:123
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
AVCodecContext * avctx
Definition: bink.c:115
static av_cold void free_bundles(BinkContext *c)
Free memory used by bundles.
Definition: bink.c:202
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1636
AVCodec ff_bink_decoder
Definition: bink.c:1384
const char * name
Name of the codec implementation.
Definition: avcodec.h:3475
int col_lastval
value of last decoded high nibble in "colours" data type
Definition: bink.c:127
#define FFMAX(a, b)
Definition: common.h:94
BinkDSPContext binkdsp
Definition: bink.c:118
DC values for interblocks with DCT.
Definition: bink.c:82
Definition: vlc.h:26
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
block is composed from runs of colours with custom scan order
Definition: bink.c:137
common internal API header
block is filled with single colour
Definition: bink.c:140
static av_cold void binkb_calc_quant(void)
Calculate quantization tables for version b.
Definition: bink.c:1281
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:282
Half-pel DSP context.
Definition: hpeldsp.h:45
#define b
Definition: input.c:41
#define FFMIN(a, b)
Definition: common.h:96
#define width
int width
picture width / height.
Definition: avcodec.h:1729
static int binkb_decode_plane(BinkContext *c, AVFrame *frame, GetBitContext *gb, int plane_idx, int is_key, int is_chroma)
Definition: bink.c:820
Y components of motion value.
Definition: bink.c:50
void(* idct_add)(uint8_t *dest, int line_size, int32_t *block)
Definition: binkdsp.h:36
number of coefficients for residue blocks
Definition: bink.c:55
int32_t
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
int has_alpha
Definition: bink.c:121
block has size 16x16
Definition: bink.c:135
static const uint8_t binkb_inter_seed[64]
Definition: binkdata.h:636
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:519
#define INIT_VLC_LE
Definition: vlc.h:54
int swap_planes
Definition: bink.c:122
if(ret)
static const uint8_t binkb_runbits[64]
Definition: binkdata.h:614
static int bink_decode_plane(BinkContext *c, AVFrame *frame, GetBitContext *gb, int plane_idx, int is_chroma)
Definition: bink.c:988
int table_allocated
Definition: vlc.h:29
data needed to decode 4-bit Huffman-coded value
Definition: bink.c:91
uint8_t * cur_dec
pointer to the not yet decoded part of the buffer
Definition: bink.c:107
Half-pel DSP functions.
Libavcodec external API header.
quantizer values for intrablocks with DCT
Definition: bink.c:53
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
void(* add_pixels8)(uint8_t *av_restrict pixels, int16_t *block, int line_size)
Definition: binkdsp.h:38
#define DC_START_BITS
number of bits used to store first DC value in bundle
Definition: bink.c:474
main external API structure.
Definition: avcodec.h:1556
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1581
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1919
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
static av_cold int decode_init(AVCodecContext *avctx)
Definition: bink.c:1310
int extradata_size
Definition: avcodec.h:1658
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:488
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
static const int32_t bink_intra_quant[16][64]
Definition: binkdata.h:288
DC values for interblocks with DCT.
Definition: bink.c:52
Sources
IDs for different data types used in Bink video codec.
Definition: bink.c:74
block is filled with two colours following custom pattern
Definition: bink.c:142
static av_cold void binkb_init_bundles(BinkContext *c)
Definition: bink.c:548
static int32_t binkb_intra_quant[16][64]
Definition: bink.c:68
static int read_dct_coeffs(BinkContext *c, GetBitContext *gb, int32_t block[64], const uint8_t *scan, int *coef_count_, int coef_idx[64], int q)
Read 8x8 block of DCT coefficients.
Definition: bink.c:612
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:616
8x8 block types
Definition: bink.c:46
static const uint8_t binkb_num[16]
Definition: binkdata.h:647
#define GET_HUFF(gb, tree)
Definition: bink.c:96
run lengths for special fill block
Definition: bink.c:83
Y components of motion value.
Definition: bink.c:80
static VLC bink_trees[16]
Definition: bink.c:40
static void merge(GetBitContext *gb, uint8_t *dst, uint8_t *src, int size)
Merge two consequent lists of equal size depending on bits read.
Definition: bink.c:217
const uint8_t * quant
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
Bundle bundle[BINKB_NB_SRC]
bundles for decoding all data types
Definition: bink.c:125
#define flags(name, subs,...)
Definition: cbs_av1.c:606
static void flush(AVCodecContext *avctx)
Definition: bink.c:1377
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
pixel values used for different block types
Definition: bink.c:77
AVFrame * last
Definition: bink.c:119
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:518
X components of motion value.
Definition: bink.c:79
#define LOCAL_ALIGNED_32(t, v,...)
Definition: internal.h:137
uint8_t * cur_ptr
pointer to the data that is not read from buffer yet
Definition: bink.c:108
#define BINK_FLAG_ALPHA
Definition: bink.c:37
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
static const uint8_t binkb_intra_seed[64]
Definition: binkdata.h:625
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
static int binkb_read_bundle(BinkContext *c, GetBitContext *gb, int bundle_num)
Definition: bink.c:555
common internal api header.
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
static void init_lengths(BinkContext *c, int width, int bw)
Initialize length in all bundles.
Definition: bink.c:153
static av_cold int init_bundles(BinkContext *c)
Allocate memory for bundles.
Definition: bink.c:178
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
static int read_colors(GetBitContext *gb, Bundle *b, BinkContext *c)
Definition: bink.c:435
static int read_block_types(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
Definition: bink.c:372
static void read_tree(GetBitContext *gb, Tree *tree)
Read information about Huffman tree used to decode data.
Definition: bink.c:244
uint8_t syms[16]
leaf value to symbol mapping
Definition: bink.c:93
static int read_dcs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b, int start_bits, int has_sign)
Definition: bink.c:476
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
Definition: bink.c:1220
DC values for intrablocks with DCT.
Definition: bink.c:51
void * priv_data
Definition: avcodec.h:1583
static int read_motion_values(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
Definition: bink.c:338
motion block with some difference added
Definition: bink.c:138
int len
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static int bink_put_pixels(BinkContext *c, uint8_t *dst, uint8_t *prev, int stride, uint8_t *ref_start, uint8_t *ref_end)
Definition: bink.c:970
static const int binkb_bundle_sizes[BINKB_NB_SRC]
Definition: bink.c:60
int version
internal Bink file version
Definition: bink.c:120
static const int binkb_bundle_signed[BINKB_NB_SRC]
Definition: bink.c:64
static av_cold int decode_end(AVCodecContext *avctx)
Definition: bink.c:1367
FILE * out
Definition: movenc.c:54
BlockDSPContext bdsp
Definition: bink.c:116
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:131
#define av_freep(p)
#define VLC_TYPE
Definition: vlc.h:24
#define FFSWAP(type, a, b)
Definition: common.h:99
static void read_bundle(GetBitContext *gb, BinkContext *c, int bundle_num)
Prepare bundle for decoding data.
Definition: bink.c:285
static const uint8_t bink_rlelens[4]
Definition: bink.c:370
#define stride
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
pixel values used for different block types
Definition: bink.c:47
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
static int get_value(BinkContext *c, int bundle)
Retrieve next value from bundle.
Definition: bink.c:528
This structure stores compressed data.
Definition: avcodec.h:1445
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1167
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
DC values for intrablocks with DCT.
Definition: bink.c:81
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:972
OldSources
IDs for different data types used in old version of Bink video codec.
Definition: bink.c:45
op_fill_func fill_block_tab[2]
Definition: blockdsp.h:39
static uint8_t tmp[11]
Definition: aes_ctr.c:26