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 Libav.
7  *
8  * Libav 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  * Libav 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 Libav; 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/imgutils.h"
24 #include "avcodec.h"
25 #include "dsputil.h"
26 #include "binkdata.h"
27 #include "binkdsp.h"
28 #include "internal.h"
29 #include "mathops.h"
30 
31 #define BITSTREAM_READER_LE
32 #include "get_bits.h"
33 
34 #define BINK_FLAG_ALPHA 0x00100000
35 #define BINK_FLAG_GRAY 0x00020000
36 
37 static VLC bink_trees[16];
38 
42 enum OldSources {
53 
55 };
56 
57 static const int binkb_bundle_sizes[BINKB_NB_SRC] = {
58  4, 8, 8, 5, 5, 11, 11, 4, 4, 7
59 };
60 
61 static const int binkb_bundle_signed[BINKB_NB_SRC] = {
62  0, 0, 0, 1, 1, 0, 1, 0, 0, 0
63 };
64 
65 static int32_t binkb_intra_quant[16][64];
66 static int32_t binkb_inter_quant[16][64];
67 
71 enum Sources {
81 
83 };
84 
88 typedef struct Tree {
89  int vlc_num;
90  uint8_t syms[16];
91 } Tree;
92 
93 #define GET_HUFF(gb, tree) (tree).syms[get_vlc2(gb, bink_trees[(tree).vlc_num].table,\
94  bink_trees[(tree).vlc_num].bits, 1)]
95 
99 typedef struct Bundle {
100  int len;
106 } Bundle;
107 
108 /*
109  * Decoder context
110  */
111 typedef struct BinkContext {
116  int version;
119 
123 } BinkContext;
124 
139 };
140 
148 static void init_lengths(BinkContext *c, int width, int bw)
149 {
150  width = FFALIGN(width, 8);
151 
152  c->bundle[BINK_SRC_BLOCK_TYPES].len = av_log2((width >> 3) + 511) + 1;
153 
154  c->bundle[BINK_SRC_SUB_BLOCK_TYPES].len = av_log2((width >> 4) + 511) + 1;
155 
156  c->bundle[BINK_SRC_COLORS].len = av_log2(bw*64 + 511) + 1;
157 
161  c->bundle[BINK_SRC_Y_OFF].len = av_log2((width >> 3) + 511) + 1;
162 
163  c->bundle[BINK_SRC_PATTERN].len = av_log2((bw << 3) + 511) + 1;
164 
165  c->bundle[BINK_SRC_RUN].len = av_log2(bw*48 + 511) + 1;
166 }
167 
174 {
175  int bw, bh, blocks;
176  int i;
177 
178  bw = (c->avctx->width + 7) >> 3;
179  bh = (c->avctx->height + 7) >> 3;
180  blocks = bw * bh;
181 
182  for (i = 0; i < BINKB_NB_SRC; i++) {
183  c->bundle[i].data = av_malloc(blocks * 64);
184  c->bundle[i].data_end = c->bundle[i].data + blocks * 64;
185  }
186 }
187 
194 {
195  int i;
196  for (i = 0; i < BINKB_NB_SRC; i++)
197  av_freep(&c->bundle[i].data);
198 }
199 
208 static void merge(GetBitContext *gb, uint8_t *dst, uint8_t *src, int size)
209 {
210  uint8_t *src2 = src + size;
211  int size2 = size;
212 
213  do {
214  if (!get_bits1(gb)) {
215  *dst++ = *src++;
216  size--;
217  } else {
218  *dst++ = *src2++;
219  size2--;
220  }
221  } while (size && size2);
222 
223  while (size--)
224  *dst++ = *src++;
225  while (size2--)
226  *dst++ = *src2++;
227 }
228 
235 static void read_tree(GetBitContext *gb, Tree *tree)
236 {
237  uint8_t tmp1[16] = { 0 }, tmp2[16], *in = tmp1, *out = tmp2;
238  int i, t, len;
239 
240  tree->vlc_num = get_bits(gb, 4);
241  if (!tree->vlc_num) {
242  for (i = 0; i < 16; i++)
243  tree->syms[i] = i;
244  return;
245  }
246  if (get_bits1(gb)) {
247  len = get_bits(gb, 3);
248  for (i = 0; i <= len; i++) {
249  tree->syms[i] = get_bits(gb, 4);
250  tmp1[tree->syms[i]] = 1;
251  }
252  for (i = 0; i < 16 && len < 16 - 1; i++)
253  if (!tmp1[i])
254  tree->syms[++len] = i;
255  } else {
256  len = get_bits(gb, 2);
257  for (i = 0; i < 16; i++)
258  in[i] = i;
259  for (i = 0; i <= len; i++) {
260  int size = 1 << i;
261  for (t = 0; t < 16; t += size << 1)
262  merge(gb, out + t, in + t, size);
263  FFSWAP(uint8_t*, in, out);
264  }
265  memcpy(tree->syms, in, 16);
266  }
267 }
268 
276 static void read_bundle(GetBitContext *gb, BinkContext *c, int bundle_num)
277 {
278  int i;
279 
280  if (bundle_num == BINK_SRC_COLORS) {
281  for (i = 0; i < 16; i++)
282  read_tree(gb, &c->col_high[i]);
283  c->col_lastval = 0;
284  }
285  if (bundle_num != BINK_SRC_INTRA_DC && bundle_num != BINK_SRC_INTER_DC)
286  read_tree(gb, &c->bundle[bundle_num].tree);
287  c->bundle[bundle_num].cur_dec =
288  c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data;
289 }
290 
298 #define CHECK_READ_VAL(gb, b, t) \
299  if (!b->cur_dec || (b->cur_dec > b->cur_ptr)) \
300  return 0; \
301  t = get_bits(gb, b->len); \
302  if (!t) { \
303  b->cur_dec = NULL; \
304  return 0; \
305  } \
306 
307 static int read_runs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
308 {
309  int t, v;
310  const uint8_t *dec_end;
311 
312  CHECK_READ_VAL(gb, b, t);
313  dec_end = b->cur_dec + t;
314  if (dec_end > b->data_end) {
315  av_log(avctx, AV_LOG_ERROR, "Run value went out of bounds\n");
316  return -1;
317  }
318  if (get_bits1(gb)) {
319  v = get_bits(gb, 4);
320  memset(b->cur_dec, v, t);
321  b->cur_dec += t;
322  } else {
323  while (b->cur_dec < dec_end)
324  *b->cur_dec++ = GET_HUFF(gb, b->tree);
325  }
326  return 0;
327 }
328 
330 {
331  int t, sign, v;
332  const uint8_t *dec_end;
333 
334  CHECK_READ_VAL(gb, b, t);
335  dec_end = b->cur_dec + t;
336  if (dec_end > b->data_end) {
337  av_log(avctx, AV_LOG_ERROR, "Too many motion values\n");
338  return -1;
339  }
340  if (get_bits1(gb)) {
341  v = get_bits(gb, 4);
342  if (v) {
343  sign = -get_bits1(gb);
344  v = (v ^ sign) - sign;
345  }
346  memset(b->cur_dec, v, t);
347  b->cur_dec += t;
348  } else {
349  while (b->cur_dec < dec_end) {
350  v = GET_HUFF(gb, b->tree);
351  if (v) {
352  sign = -get_bits1(gb);
353  v = (v ^ sign) - sign;
354  }
355  *b->cur_dec++ = v;
356  }
357  }
358  return 0;
359 }
360 
361 static const uint8_t bink_rlelens[4] = { 4, 8, 12, 32 };
362 
364 {
365  int t, v;
366  int last = 0;
367  const uint8_t *dec_end;
368 
369  CHECK_READ_VAL(gb, b, t);
370  dec_end = b->cur_dec + t;
371  if (dec_end > b->data_end) {
372  av_log(avctx, AV_LOG_ERROR, "Too many block type values\n");
373  return -1;
374  }
375  if (get_bits1(gb)) {
376  v = get_bits(gb, 4);
377  memset(b->cur_dec, v, t);
378  b->cur_dec += t;
379  } else {
380  while (b->cur_dec < dec_end) {
381  v = GET_HUFF(gb, b->tree);
382  if (v < 12) {
383  last = v;
384  *b->cur_dec++ = v;
385  } else {
386  int run = bink_rlelens[v - 12];
387 
388  if (dec_end - b->cur_dec < run)
389  return -1;
390  memset(b->cur_dec, last, run);
391  b->cur_dec += run;
392  }
393  }
394  }
395  return 0;
396 }
397 
399 {
400  int t, v;
401  const uint8_t *dec_end;
402 
403  CHECK_READ_VAL(gb, b, t);
404  dec_end = b->cur_dec + t;
405  if (dec_end > b->data_end) {
406  av_log(avctx, AV_LOG_ERROR, "Too many pattern values\n");
407  return -1;
408  }
409  while (b->cur_dec < dec_end) {
410  v = GET_HUFF(gb, b->tree);
411  v |= GET_HUFF(gb, b->tree) << 4;
412  *b->cur_dec++ = v;
413  }
414 
415  return 0;
416 }
417 
419 {
420  int t, sign, v;
421  const uint8_t *dec_end;
422 
423  CHECK_READ_VAL(gb, b, t);
424  dec_end = b->cur_dec + t;
425  if (dec_end > b->data_end) {
426  av_log(c->avctx, AV_LOG_ERROR, "Too many color values\n");
427  return -1;
428  }
429  if (get_bits1(gb)) {
430  c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]);
431  v = GET_HUFF(gb, b->tree);
432  v = (c->col_lastval << 4) | v;
433  if (c->version < 'i') {
434  sign = ((int8_t) v) >> 7;
435  v = ((v & 0x7F) ^ sign) - sign;
436  v += 0x80;
437  }
438  memset(b->cur_dec, v, t);
439  b->cur_dec += t;
440  } else {
441  while (b->cur_dec < dec_end) {
442  c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]);
443  v = GET_HUFF(gb, b->tree);
444  v = (c->col_lastval << 4) | v;
445  if (c->version < 'i') {
446  sign = ((int8_t) v) >> 7;
447  v = ((v & 0x7F) ^ sign) - sign;
448  v += 0x80;
449  }
450  *b->cur_dec++ = v;
451  }
452  }
453  return 0;
454 }
455 
457 #define DC_START_BITS 11
458 
459 static int read_dcs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b,
460  int start_bits, int has_sign)
461 {
462  int i, j, len, len2, bsize, sign, v, v2;
463  int16_t *dst = (int16_t*)b->cur_dec;
464  int16_t *dst_end = (int16_t*)b->data_end;
465 
466  CHECK_READ_VAL(gb, b, len);
467  v = get_bits(gb, start_bits - has_sign);
468  if (v && has_sign) {
469  sign = -get_bits1(gb);
470  v = (v ^ sign) - sign;
471  }
472  if (dst_end - dst < 1)
473  return -1;
474  *dst++ = v;
475  len--;
476  for (i = 0; i < len; i += 8) {
477  len2 = FFMIN(len - i, 8);
478  if (dst_end - dst < len2)
479  return -1;
480  bsize = get_bits(gb, 4);
481  if (bsize) {
482  for (j = 0; j < len2; j++) {
483  v2 = get_bits(gb, bsize);
484  if (v2) {
485  sign = -get_bits1(gb);
486  v2 = (v2 ^ sign) - sign;
487  }
488  v += v2;
489  *dst++ = v;
490  if (v < -32768 || v > 32767) {
491  av_log(avctx, AV_LOG_ERROR, "DC value went out of bounds: %d\n", v);
492  return -1;
493  }
494  }
495  } else {
496  for (j = 0; j < len2; j++)
497  *dst++ = v;
498  }
499  }
500 
501  b->cur_dec = (uint8_t*)dst;
502  return 0;
503 }
504 
511 static inline int get_value(BinkContext *c, int bundle)
512 {
513  int ret;
514 
515  if (bundle < BINK_SRC_X_OFF || bundle == BINK_SRC_RUN)
516  return *c->bundle[bundle].cur_ptr++;
517  if (bundle == BINK_SRC_X_OFF || bundle == BINK_SRC_Y_OFF)
518  return (int8_t)*c->bundle[bundle].cur_ptr++;
519  ret = *(int16_t*)c->bundle[bundle].cur_ptr;
520  c->bundle[bundle].cur_ptr += 2;
521  return ret;
522 }
523 
524 static void binkb_init_bundle(BinkContext *c, int bundle_num)
525 {
526  c->bundle[bundle_num].cur_dec =
527  c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data;
528  c->bundle[bundle_num].len = 13;
529 }
530 
532 {
533  int i;
534  for (i = 0; i < BINKB_NB_SRC; i++)
535  binkb_init_bundle(c, i);
536 }
537 
538 static int binkb_read_bundle(BinkContext *c, GetBitContext *gb, int bundle_num)
539 {
540  const int bits = binkb_bundle_sizes[bundle_num];
541  const int mask = 1 << (bits - 1);
542  const int issigned = binkb_bundle_signed[bundle_num];
543  Bundle *b = &c->bundle[bundle_num];
544  int i, len;
545 
546  CHECK_READ_VAL(gb, b, len);
547  if (b->data_end - b->cur_dec < len * (1 + (bits > 8)))
548  return -1;
549  if (bits <= 8) {
550  if (!issigned) {
551  for (i = 0; i < len; i++)
552  *b->cur_dec++ = get_bits(gb, bits);
553  } else {
554  for (i = 0; i < len; i++)
555  *b->cur_dec++ = get_bits(gb, bits) - mask;
556  }
557  } else {
558  int16_t *dst = (int16_t*)b->cur_dec;
559 
560  if (!issigned) {
561  for (i = 0; i < len; i++)
562  *dst++ = get_bits(gb, bits);
563  } else {
564  for (i = 0; i < len; i++)
565  *dst++ = get_bits(gb, bits) - mask;
566  }
567  b->cur_dec = (uint8_t*)dst;
568  }
569  return 0;
570 }
571 
572 static inline int binkb_get_value(BinkContext *c, int bundle_num)
573 {
574  int16_t ret;
575  const int bits = binkb_bundle_sizes[bundle_num];
576 
577  if (bits <= 8) {
578  int val = *c->bundle[bundle_num].cur_ptr++;
579  return binkb_bundle_signed[bundle_num] ? (int8_t)val : val;
580  }
581  ret = *(int16_t*)c->bundle[bundle_num].cur_ptr;
582  c->bundle[bundle_num].cur_ptr += 2;
583  return ret;
584 }
585 
595 static int read_dct_coeffs(GetBitContext *gb, int32_t block[64], const uint8_t *scan,
596  const int32_t quant_matrices[16][64], int q)
597 {
598  int coef_list[128];
599  int mode_list[128];
600  int i, t, bits, ccoef, mode, sign;
601  int list_start = 64, list_end = 64, list_pos;
602  int coef_count = 0;
603  int coef_idx[64];
604  int quant_idx;
605  const int32_t *quant;
606 
607  coef_list[list_end] = 4; mode_list[list_end++] = 0;
608  coef_list[list_end] = 24; mode_list[list_end++] = 0;
609  coef_list[list_end] = 44; mode_list[list_end++] = 0;
610  coef_list[list_end] = 1; mode_list[list_end++] = 3;
611  coef_list[list_end] = 2; mode_list[list_end++] = 3;
612  coef_list[list_end] = 3; mode_list[list_end++] = 3;
613 
614  for (bits = get_bits(gb, 4) - 1; bits >= 0; bits--) {
615  list_pos = list_start;
616  while (list_pos < list_end) {
617  if (!(mode_list[list_pos] | coef_list[list_pos]) || !get_bits1(gb)) {
618  list_pos++;
619  continue;
620  }
621  ccoef = coef_list[list_pos];
622  mode = mode_list[list_pos];
623  switch (mode) {
624  case 0:
625  coef_list[list_pos] = ccoef + 4;
626  mode_list[list_pos] = 1;
627  case 2:
628  if (mode == 2) {
629  coef_list[list_pos] = 0;
630  mode_list[list_pos++] = 0;
631  }
632  for (i = 0; i < 4; i++, ccoef++) {
633  if (get_bits1(gb)) {
634  coef_list[--list_start] = ccoef;
635  mode_list[ list_start] = 3;
636  } else {
637  if (!bits) {
638  t = 1 - (get_bits1(gb) << 1);
639  } else {
640  t = get_bits(gb, bits) | 1 << bits;
641  sign = -get_bits1(gb);
642  t = (t ^ sign) - sign;
643  }
644  block[scan[ccoef]] = t;
645  coef_idx[coef_count++] = ccoef;
646  }
647  }
648  break;
649  case 1:
650  mode_list[list_pos] = 2;
651  for (i = 0; i < 3; i++) {
652  ccoef += 4;
653  coef_list[list_end] = ccoef;
654  mode_list[list_end++] = 2;
655  }
656  break;
657  case 3:
658  if (!bits) {
659  t = 1 - (get_bits1(gb) << 1);
660  } else {
661  t = get_bits(gb, bits) | 1 << bits;
662  sign = -get_bits1(gb);
663  t = (t ^ sign) - sign;
664  }
665  block[scan[ccoef]] = t;
666  coef_idx[coef_count++] = ccoef;
667  coef_list[list_pos] = 0;
668  mode_list[list_pos++] = 0;
669  break;
670  }
671  }
672  }
673 
674  if (q == -1) {
675  quant_idx = get_bits(gb, 4);
676  } else {
677  quant_idx = q;
678  }
679 
680  if (quant_idx >= 16)
681  return AVERROR_INVALIDDATA;
682 
683  quant = quant_matrices[quant_idx];
684 
685  block[0] = (block[0] * quant[0]) >> 11;
686  for (i = 0; i < coef_count; i++) {
687  int idx = coef_idx[i];
688  block[scan[idx]] = (block[scan[idx]] * quant[idx]) >> 11;
689  }
690 
691  return 0;
692 }
693 
702 static int read_residue(GetBitContext *gb, DCTELEM block[64], int masks_count)
703 {
704  int coef_list[128];
705  int mode_list[128];
706  int i, sign, mask, ccoef, mode;
707  int list_start = 64, list_end = 64, list_pos;
708  int nz_coeff[64];
709  int nz_coeff_count = 0;
710 
711  coef_list[list_end] = 4; mode_list[list_end++] = 0;
712  coef_list[list_end] = 24; mode_list[list_end++] = 0;
713  coef_list[list_end] = 44; mode_list[list_end++] = 0;
714  coef_list[list_end] = 0; mode_list[list_end++] = 2;
715 
716  for (mask = 1 << get_bits(gb, 3); mask; mask >>= 1) {
717  for (i = 0; i < nz_coeff_count; i++) {
718  if (!get_bits1(gb))
719  continue;
720  if (block[nz_coeff[i]] < 0)
721  block[nz_coeff[i]] -= mask;
722  else
723  block[nz_coeff[i]] += mask;
724  masks_count--;
725  if (masks_count < 0)
726  return 0;
727  }
728  list_pos = list_start;
729  while (list_pos < list_end) {
730  if (!(coef_list[list_pos] | mode_list[list_pos]) || !get_bits1(gb)) {
731  list_pos++;
732  continue;
733  }
734  ccoef = coef_list[list_pos];
735  mode = mode_list[list_pos];
736  switch (mode) {
737  case 0:
738  coef_list[list_pos] = ccoef + 4;
739  mode_list[list_pos] = 1;
740  case 2:
741  if (mode == 2) {
742  coef_list[list_pos] = 0;
743  mode_list[list_pos++] = 0;
744  }
745  for (i = 0; i < 4; i++, ccoef++) {
746  if (get_bits1(gb)) {
747  coef_list[--list_start] = ccoef;
748  mode_list[ list_start] = 3;
749  } else {
750  nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
751  sign = -get_bits1(gb);
752  block[bink_scan[ccoef]] = (mask ^ sign) - sign;
753  masks_count--;
754  if (masks_count < 0)
755  return 0;
756  }
757  }
758  break;
759  case 1:
760  mode_list[list_pos] = 2;
761  for (i = 0; i < 3; i++) {
762  ccoef += 4;
763  coef_list[list_end] = ccoef;
764  mode_list[list_end++] = 2;
765  }
766  break;
767  case 3:
768  nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
769  sign = -get_bits1(gb);
770  block[bink_scan[ccoef]] = (mask ^ sign) - sign;
771  coef_list[list_pos] = 0;
772  mode_list[list_pos++] = 0;
773  masks_count--;
774  if (masks_count < 0)
775  return 0;
776  break;
777  }
778  }
779  }
780 
781  return 0;
782 }
783 
787 static inline void put_pixels8x8_overlapped(uint8_t *dst, uint8_t *src, int stride)
788 {
789  uint8_t tmp[64];
790  int i;
791  for (i = 0; i < 8; i++)
792  memcpy(tmp + i*8, src + i*stride, 8);
793  for (i = 0; i < 8; i++)
794  memcpy(dst + i*stride, tmp + i*8, 8);
795 }
796 
797 static int binkb_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
798  int is_key, int is_chroma)
799 {
800  int blk;
801  int i, j, bx, by;
802  uint8_t *dst, *ref, *ref_start, *ref_end;
803  int v, col[2];
804  const uint8_t *scan;
805  int xoff, yoff;
807  LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
808  int coordmap[64];
809  int ybias = is_key ? -15 : 0;
810  int qp;
811 
812  const int stride = c->pic.linesize[plane_idx];
813  int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3;
814  int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
815 
817  ref_start = c->pic.data[plane_idx];
818  ref_end = c->pic.data[plane_idx] + (bh * c->pic.linesize[plane_idx] + bw) * 8;
819 
820  for (i = 0; i < 64; i++)
821  coordmap[i] = (i & 7) + (i >> 3) * stride;
822 
823  for (by = 0; by < bh; by++) {
824  for (i = 0; i < BINKB_NB_SRC; i++) {
825  if (binkb_read_bundle(c, gb, i) < 0)
826  return -1;
827  }
828 
829  dst = c->pic.data[plane_idx] + 8*by*stride;
830  for (bx = 0; bx < bw; bx++, dst += 8) {
832  switch (blk) {
833  case 0:
834  break;
835  case 1:
836  scan = bink_patterns[get_bits(gb, 4)];
837  i = 0;
838  do {
839  int mode, run;
840 
841  mode = get_bits1(gb);
842  run = get_bits(gb, binkb_runbits[i]) + 1;
843 
844  i += run;
845  if (i > 64) {
846  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
847  return -1;
848  }
849  if (mode) {
851  for (j = 0; j < run; j++)
852  dst[coordmap[*scan++]] = v;
853  } else {
854  for (j = 0; j < run; j++)
855  dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
856  }
857  } while (i < 63);
858  if (i == 63)
859  dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
860  break;
861  case 2:
862  memset(dctblock, 0, sizeof(*dctblock) * 64);
863  dctblock[0] = binkb_get_value(c, BINKB_SRC_INTRA_DC);
865  read_dct_coeffs(gb, dctblock, bink_scan, binkb_intra_quant, qp);
866  c->bdsp.idct_put(dst, stride, dctblock);
867  break;
868  case 3:
869  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
870  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
871  ref = dst + xoff + yoff * stride;
872  if (ref < ref_start || ref + 8*stride > ref_end) {
873  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
874  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
875  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
876  } else {
877  put_pixels8x8_overlapped(dst, ref, stride);
878  }
879  c->dsp.clear_block(block);
881  read_residue(gb, block, v);
882  c->dsp.add_pixels8(dst, block, stride);
883  break;
884  case 4:
885  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
886  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
887  ref = dst + xoff + yoff * stride;
888  if (ref < ref_start || ref + 8 * stride > ref_end) {
889  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
890  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
891  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
892  } else {
893  put_pixels8x8_overlapped(dst, ref, stride);
894  }
895  memset(dctblock, 0, sizeof(*dctblock) * 64);
896  dctblock[0] = binkb_get_value(c, BINKB_SRC_INTER_DC);
898  read_dct_coeffs(gb, dctblock, bink_scan, binkb_inter_quant, qp);
899  c->bdsp.idct_add(dst, stride, dctblock);
900  break;
901  case 5:
903  c->dsp.fill_block_tab[1](dst, v, stride, 8);
904  break;
905  case 6:
906  for (i = 0; i < 2; i++)
907  col[i] = binkb_get_value(c, BINKB_SRC_COLORS);
908  for (i = 0; i < 8; i++) {
910  for (j = 0; j < 8; j++, v >>= 1)
911  dst[i*stride + j] = col[v & 1];
912  }
913  break;
914  case 7:
915  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
916  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
917  ref = dst + xoff + yoff * stride;
918  if (ref < ref_start || ref + 8 * stride > ref_end) {
919  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
920  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
921  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
922  } else {
923  put_pixels8x8_overlapped(dst, ref, stride);
924  }
925  break;
926  case 8:
927  for (i = 0; i < 8; i++)
928  memcpy(dst + i*stride, c->bundle[BINKB_SRC_COLORS].cur_ptr + i*8, 8);
929  c->bundle[BINKB_SRC_COLORS].cur_ptr += 64;
930  break;
931  default:
932  av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
933  return -1;
934  }
935  }
936  }
937  if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary
938  skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
939 
940  return 0;
941 }
942 
943 static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
944  int is_chroma)
945 {
946  int blk;
947  int i, j, bx, by;
948  uint8_t *dst, *prev, *ref, *ref_start, *ref_end;
949  int v, col[2];
950  const uint8_t *scan;
951  int xoff, yoff;
953  LOCAL_ALIGNED_16(uint8_t, ublock, [64]);
954  LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
955  int coordmap[64];
956 
957  const int stride = c->pic.linesize[plane_idx];
958  int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3;
959  int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
960  int width = c->avctx->width >> is_chroma;
961 
962  init_lengths(c, FFMAX(width, 8), bw);
963  for (i = 0; i < BINK_NB_SRC; i++)
964  read_bundle(gb, c, i);
965 
966  ref_start = c->last.data[plane_idx] ? c->last.data[plane_idx]
967  : c->pic.data[plane_idx];
968  ref_end = ref_start
969  + (bw - 1 + c->last.linesize[plane_idx] * (bh - 1)) * 8;
970 
971  for (i = 0; i < 64; i++)
972  coordmap[i] = (i & 7) + (i >> 3) * stride;
973 
974  for (by = 0; by < bh; by++) {
975  if (read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0)
976  return -1;
978  return -1;
979  if (read_colors(gb, &c->bundle[BINK_SRC_COLORS], c) < 0)
980  return -1;
981  if (read_patterns(c->avctx, gb, &c->bundle[BINK_SRC_PATTERN]) < 0)
982  return -1;
983  if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_X_OFF]) < 0)
984  return -1;
985  if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_Y_OFF]) < 0)
986  return -1;
987  if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0)
988  return -1;
989  if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0)
990  return -1;
991  if (read_runs(c->avctx, gb, &c->bundle[BINK_SRC_RUN]) < 0)
992  return -1;
993 
994  if (by == bh)
995  break;
996  dst = c->pic.data[plane_idx] + 8*by*stride;
997  prev = (c->last.data[plane_idx] ? c->last.data[plane_idx]
998  : c->pic.data[plane_idx]) + 8*by*stride;
999  for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) {
1000  blk = get_value(c, BINK_SRC_BLOCK_TYPES);
1001  // 16x16 block type on odd line means part of the already decoded block, so skip it
1002  if ((by & 1) && blk == SCALED_BLOCK) {
1003  bx++;
1004  dst += 8;
1005  prev += 8;
1006  continue;
1007  }
1008  switch (blk) {
1009  case SKIP_BLOCK:
1010  c->dsp.put_pixels_tab[1][0](dst, prev, stride, 8);
1011  break;
1012  case SCALED_BLOCK:
1014  switch (blk) {
1015  case RUN_BLOCK:
1016  scan = bink_patterns[get_bits(gb, 4)];
1017  i = 0;
1018  do {
1019  int run = get_value(c, BINK_SRC_RUN) + 1;
1020 
1021  i += run;
1022  if (i > 64) {
1023  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
1024  return -1;
1025  }
1026  if (get_bits1(gb)) {
1027  v = get_value(c, BINK_SRC_COLORS);
1028  for (j = 0; j < run; j++)
1029  ublock[*scan++] = v;
1030  } else {
1031  for (j = 0; j < run; j++)
1032  ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
1033  }
1034  } while (i < 63);
1035  if (i == 63)
1036  ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
1037  break;
1038  case INTRA_BLOCK:
1039  memset(dctblock, 0, sizeof(*dctblock) * 64);
1040  dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
1041  read_dct_coeffs(gb, dctblock, bink_scan, bink_intra_quant, -1);
1042  c->bdsp.idct_put(ublock, 8, dctblock);
1043  break;
1044  case FILL_BLOCK:
1045  v = get_value(c, BINK_SRC_COLORS);
1046  c->dsp.fill_block_tab[0](dst, v, stride, 16);
1047  break;
1048  case PATTERN_BLOCK:
1049  for (i = 0; i < 2; i++)
1050  col[i] = get_value(c, BINK_SRC_COLORS);
1051  for (j = 0; j < 8; j++) {
1052  v = get_value(c, BINK_SRC_PATTERN);
1053  for (i = 0; i < 8; i++, v >>= 1)
1054  ublock[i + j*8] = col[v & 1];
1055  }
1056  break;
1057  case RAW_BLOCK:
1058  for (j = 0; j < 8; j++)
1059  for (i = 0; i < 8; i++)
1060  ublock[i + j*8] = get_value(c, BINK_SRC_COLORS);
1061  break;
1062  default:
1063  av_log(c->avctx, AV_LOG_ERROR, "Incorrect 16x16 block type %d\n", blk);
1064  return -1;
1065  }
1066  if (blk != FILL_BLOCK)
1067  c->bdsp.scale_block(ublock, dst, stride);
1068  bx++;
1069  dst += 8;
1070  prev += 8;
1071  break;
1072  case MOTION_BLOCK:
1073  xoff = get_value(c, BINK_SRC_X_OFF);
1074  yoff = get_value(c, BINK_SRC_Y_OFF);
1075  ref = prev + xoff + yoff * stride;
1076  if (ref < ref_start || ref > ref_end) {
1077  av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
1078  bx*8 + xoff, by*8 + yoff);
1079  return -1;
1080  }
1081  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
1082  break;
1083  case RUN_BLOCK:
1084  scan = bink_patterns[get_bits(gb, 4)];
1085  i = 0;
1086  do {
1087  int run = get_value(c, BINK_SRC_RUN) + 1;
1088 
1089  i += run;
1090  if (i > 64) {
1091  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
1092  return -1;
1093  }
1094  if (get_bits1(gb)) {
1095  v = get_value(c, BINK_SRC_COLORS);
1096  for (j = 0; j < run; j++)
1097  dst[coordmap[*scan++]] = v;
1098  } else {
1099  for (j = 0; j < run; j++)
1100  dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
1101  }
1102  } while (i < 63);
1103  if (i == 63)
1104  dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
1105  break;
1106  case RESIDUE_BLOCK:
1107  xoff = get_value(c, BINK_SRC_X_OFF);
1108  yoff = get_value(c, BINK_SRC_Y_OFF);
1109  ref = prev + xoff + yoff * stride;
1110  if (ref < ref_start || ref > ref_end) {
1111  av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
1112  bx*8 + xoff, by*8 + yoff);
1113  return -1;
1114  }
1115  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
1116  c->dsp.clear_block(block);
1117  v = get_bits(gb, 7);
1118  read_residue(gb, block, v);
1119  c->dsp.add_pixels8(dst, block, stride);
1120  break;
1121  case INTRA_BLOCK:
1122  memset(dctblock, 0, sizeof(*dctblock) * 64);
1123  dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
1124  read_dct_coeffs(gb, dctblock, bink_scan, bink_intra_quant, -1);
1125  c->bdsp.idct_put(dst, stride, dctblock);
1126  break;
1127  case FILL_BLOCK:
1128  v = get_value(c, BINK_SRC_COLORS);
1129  c->dsp.fill_block_tab[1](dst, v, stride, 8);
1130  break;
1131  case INTER_BLOCK:
1132  xoff = get_value(c, BINK_SRC_X_OFF);
1133  yoff = get_value(c, BINK_SRC_Y_OFF);
1134  ref = prev + xoff + yoff * stride;
1135  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
1136  memset(dctblock, 0, sizeof(*dctblock) * 64);
1137  dctblock[0] = get_value(c, BINK_SRC_INTER_DC);
1138  read_dct_coeffs(gb, dctblock, bink_scan, bink_inter_quant, -1);
1139  c->bdsp.idct_add(dst, stride, dctblock);
1140  break;
1141  case PATTERN_BLOCK:
1142  for (i = 0; i < 2; i++)
1143  col[i] = get_value(c, BINK_SRC_COLORS);
1144  for (i = 0; i < 8; i++) {
1145  v = get_value(c, BINK_SRC_PATTERN);
1146  for (j = 0; j < 8; j++, v >>= 1)
1147  dst[i*stride + j] = col[v & 1];
1148  }
1149  break;
1150  case RAW_BLOCK:
1151  for (i = 0; i < 8; i++)
1152  memcpy(dst + i*stride, c->bundle[BINK_SRC_COLORS].cur_ptr + i*8, 8);
1153  c->bundle[BINK_SRC_COLORS].cur_ptr += 64;
1154  break;
1155  default:
1156  av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
1157  return -1;
1158  }
1159  }
1160  }
1161  if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary
1162  skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
1163 
1164  return 0;
1165 }
1166 
1167 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
1168 {
1169  BinkContext * const c = avctx->priv_data;
1170  GetBitContext gb;
1171  int plane, plane_idx;
1172  int bits_count = pkt->size << 3;
1173 
1174  if (c->version > 'b') {
1175  if(c->pic.data[0])
1176  avctx->release_buffer(avctx, &c->pic);
1177 
1178  if(ff_get_buffer(avctx, &c->pic) < 0){
1179  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1180  return -1;
1181  }
1182  } else {
1183  if(avctx->reget_buffer(avctx, &c->pic) < 0){
1184  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1185  return -1;
1186  }
1187  }
1188 
1189  init_get_bits(&gb, pkt->data, bits_count);
1190  if (c->has_alpha) {
1191  if (c->version >= 'i')
1192  skip_bits_long(&gb, 32);
1193  if (bink_decode_plane(c, &gb, 3, 0) < 0)
1194  return -1;
1195  }
1196  if (c->version >= 'i')
1197  skip_bits_long(&gb, 32);
1198 
1199  for (plane = 0; plane < 3; plane++) {
1200  plane_idx = (!plane || !c->swap_planes) ? plane : (plane ^ 3);
1201 
1202  if (c->version > 'b') {
1203  if (bink_decode_plane(c, &gb, plane_idx, !!plane) < 0)
1204  return -1;
1205  } else {
1206  if (binkb_decode_plane(c, &gb, plane_idx, !pkt->pts, !!plane) < 0)
1207  return -1;
1208  }
1209  if (get_bits_count(&gb) >= bits_count)
1210  break;
1211  }
1212  emms_c();
1213 
1214  *got_frame = 1;
1215  *(AVFrame*)data = c->pic;
1216 
1217  if (c->version > 'b')
1218  FFSWAP(AVFrame, c->pic, c->last);
1219 
1220  /* always report that the buffer was completely consumed */
1221  return pkt->size;
1222 }
1223 
1227 static av_cold void binkb_calc_quant(void)
1228 {
1229  uint8_t inv_bink_scan[64];
1230  double s[64];
1231  int i, j;
1232 
1233  for (j = 0; j < 8; j++) {
1234  for (i = 0; i < 8; i++) {
1235  if (j && j != 4)
1236  if (i && i != 4)
1237  s[j*8 + i] = cos(j * M_PI/16.0) * cos(i * M_PI/16.0) * 2.0;
1238  else
1239  s[j*8 + i] = cos(j * M_PI/16.0) * sqrt(2.0);
1240  else
1241  if (i && i != 4)
1242  s[j*8 + i] = cos(i * M_PI/16.0) * sqrt(2.0);
1243  else
1244  s[j*8 + i] = 1.0;
1245  }
1246  }
1247 
1248  for (i = 0; i < 64; i++)
1249  inv_bink_scan[bink_scan[i]] = i;
1250 
1251  for (j = 0; j < 16; j++) {
1252  for (i = 0; i < 64; i++) {
1253  int k = inv_bink_scan[i];
1254  if (s[i] == 1.0) {
1255  binkb_intra_quant[j][k] = (1L << 12) * binkb_intra_seed[i] *
1256  binkb_num[j]/binkb_den[j];
1257  binkb_inter_quant[j][k] = (1L << 12) * binkb_inter_seed[i] *
1258  binkb_num[j]/binkb_den[j];
1259  } else {
1260  binkb_intra_quant[j][k] = (1L << 12) * binkb_intra_seed[i] * s[i] *
1261  binkb_num[j]/(double)binkb_den[j];
1262  binkb_inter_quant[j][k] = (1L << 12) * binkb_inter_seed[i] * s[i] *
1263  binkb_num[j]/(double)binkb_den[j];
1264  }
1265  }
1266  }
1267 }
1268 
1270 {
1271  BinkContext * const c = avctx->priv_data;
1272  static VLC_TYPE table[16 * 128][2];
1273  static int binkb_initialised = 0;
1274  int i;
1275  int flags;
1276 
1277  c->version = avctx->codec_tag >> 24;
1278  if (avctx->extradata_size < 4) {
1279  av_log(avctx, AV_LOG_ERROR, "Extradata missing or too short\n");
1280  return -1;
1281  }
1282  flags = AV_RL32(avctx->extradata);
1283  c->has_alpha = flags & BINK_FLAG_ALPHA;
1284  c->swap_planes = c->version >= 'h';
1285  if (!bink_trees[15].table) {
1286  for (i = 0; i < 16; i++) {
1287  const int maxbits = bink_tree_lens[i][15];
1288  bink_trees[i].table = table + i*128;
1289  bink_trees[i].table_allocated = 1 << maxbits;
1290  init_vlc(&bink_trees[i], maxbits, 16,
1291  bink_tree_lens[i], 1, 1,
1293  }
1294  }
1295  c->avctx = avctx;
1296 
1297  c->pic.data[0] = NULL;
1298 
1299  if (av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0) {
1300  return 1;
1301  }
1302 
1304 
1305  avctx->idct_algo = FF_IDCT_BINK;
1306  ff_dsputil_init(&c->dsp, avctx);
1307  ff_binkdsp_init(&c->bdsp);
1308 
1309  init_bundles(c);
1310 
1311  if (c->version == 'b') {
1312  if (!binkb_initialised) {
1313  binkb_calc_quant();
1314  binkb_initialised = 1;
1315  }
1316  }
1317 
1318  return 0;
1319 }
1320 
1322 {
1323  BinkContext * const c = avctx->priv_data;
1324 
1325  if (c->pic.data[0])
1326  avctx->release_buffer(avctx, &c->pic);
1327  if (c->last.data[0])
1328  avctx->release_buffer(avctx, &c->last);
1329 
1330  free_bundles(c);
1331  return 0;
1332 }
1333 
1335  .name = "binkvideo",
1336  .type = AVMEDIA_TYPE_VIDEO,
1337  .id = AV_CODEC_ID_BINKVIDEO,
1338  .priv_data_size = sizeof(BinkContext),
1339  .init = decode_init,
1340  .close = decode_end,
1341  .decode = decode_frame,
1342  .long_name = NULL_IF_CONFIG_SMALL("Bink video"),
1343  .capabilities = CODEC_CAP_DR1,
1344 };
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:61
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: dsputil.h:259
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2656
static const uint8_t bink_tree_lens[16][16]
Definition: binkdata.h:106
int size
8-bit values for 2-colour pattern fill
Definition: bink.c:45
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
BinkDSPContext bdsp
Definition: bink.c:114
static const uint8_t bink_tree_bits[16][16]
Definition: binkdata.h:39
#define CHECK_READ_VAL(gb, b, t)
common check before starting decoding bundle data
Definition: bink.c:298
static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx, int is_chroma)
Definition: bink.c:943
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
Definition: avcodec.h:2259
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
void(* scale_block)(const uint8_t src[64], uint8_t *dst, int linesize)
Definition: binkdsp.h:35
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:197
static void binkb_init_bundle(BinkContext *c, int bundle_num)
Definition: bink.c:524
static const uint8_t binkb_den[16]
Definition: binkdata.h:651
int size
Definition: avcodec.h:916
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1533
8-bit values for 2-colour pattern fill
Definition: bink.c:75
static const uint8_t bink_scan[64]
Bink DCT and residue 8x8 block scan order.
Definition: binkdata.h:28
#define VLC_TYPE
Definition: get_bits.h:61
uint8_t run
Definition: svq3.c:124
#define blk(i)
Definition: sha.c:171
8x8 block types
Definition: bink.c:72
Tree col_high[16]
trees for decoding high nibble in "colours" data type
Definition: bink.c:121
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:2960
AVFrame pic
Definition: bink.c:115
16x16 block types (a subset of 8x8 block types)
Definition: bink.c:73
int len
length of number of entries to decode (in bits)
Definition: bink.c:100
int(* reget_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called at the beginning of a frame to get cr buffer for it.
Definition: avcodec.h:2273
static int32_t binkb_inter_quant[16][64]
Definition: bink.c:66
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:151
quantizer values for interblocks with DCT
Definition: bink.c:51
static int read_patterns(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
Definition: bink.c:398
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
X components of motion value.
Definition: bink.c:46
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:102
motion block with DCT applied to the difference
Definition: bink.c:136
uint8_t bits
Definition: crc.c:31
uint8_t
intra DCT block
Definition: bink.c:134
static int binkb_get_value(BinkContext *c, int bundle_num)
Definition: bink.c:572
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:787
Tree tree
Huffman tree-related data.
Definition: bink.c:101
struct Tree Tree
data needed to decode 4-bit Huffman-coded value
BlockTypes
Bink video block types.
Definition: bink.c:128
#define b
Definition: input.c:52
#define emms_c()
Definition: internal.h:145
uncoded 8x8 block
Definition: bink.c:138
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1454
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:915
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:192
static int flags
Definition: log.c:42
int vlc_num
tree number (in bink_trees[])
Definition: bink.c:89
skipped block
Definition: bink.c:129
static av_cold void init_bundles(BinkContext *c)
Allocate memory for bundles.
Definition: bink.c:173
bitstream reader API header.
static int read_runs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
Definition: bink.c:307
data structure used for decoding single Bink data type
Definition: bink.c:99
#define LOCAL_ALIGNED_16(t, v,...)
Definition: dsputil.h:602
static const uint8_t bink_patterns[16][64]
Definition: binkdata.h:125
static float t
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
uint8_t * data
buffer for decoded symbols
Definition: bink.c:102
Bink DSP routines.
block is copied from previous frame with some offset
Definition: bink.c:131
static int read_dct_coeffs(GetBitContext *gb, int32_t block[64], const uint8_t *scan, const int32_t quant_matrices[16][64], int q)
Read 8x8 block of DCT coefficients.
Definition: bink.c:595
uint8_t * data_end
buffer end
Definition: bink.c:103
static const uint16_t mask[17]
Definition: lzw.c:38
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
AVCodecContext * avctx
Definition: bink.c:112
static av_cold void free_bundles(BinkContext *c)
Free memory used by bundles.
Definition: bink.c:193
AVCodec ff_bink_decoder
Definition: bink.c:1334
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
int col_lastval
value of last decoded high nibble in "colours" data type
Definition: bink.c:122
void(* clear_block)(DCTELEM *block)
Definition: dsputil.h:218
DC values for interblocks with DCT.
Definition: bink.c:79
Definition: get_bits.h:63
void(* add_pixels8)(uint8_t *pixels, DCTELEM *block, int line_size)
Definition: dsputil.h:206
block is composed from runs of colours with custom scan order
Definition: bink.c:132
block is filled with single colour
Definition: bink.c:135
static av_cold void binkb_calc_quant(void)
Caclulate quantization tables for version b.
Definition: bink.c:1227
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:220
static DCTELEM block[64]
Definition: dct-test.c:169
int width
picture width / height.
Definition: avcodec.h:1508
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:2661
Y components of motion value.
Definition: bink.c:47
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
Definition: utils.c:464
number of coefficients for residue blocks
Definition: bink.c:52
int32_t
int has_alpha
Definition: bink.c:117
#define AV_RL32
Definition: intreadwrite.h:146
#define L(x)
Definition: vp56_arith.h:36
block has size 16x16
Definition: bink.c:130
static const uint8_t binkb_inter_seed[64]
Definition: binkdata.h:636
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:433
int swap_planes
Definition: bink.c:118
static const uint8_t binkb_runbits[64]
Definition: binkdata.h:614
int table_allocated
Definition: get_bits.h:66
data needed to decode 4-bit Huffman-coded value
Definition: bink.c:88
uint8_t * cur_dec
pointer to the not yet decoded part of the buffer
Definition: bink.c:104
NULL
Definition: eval.c:52
static int width
Definition: utils.c:156
external API header
quantizer values for intrablocks with DCT
Definition: bink.c:50
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
#define DC_START_BITS
number of bits used to store first DC value in bundle
Definition: bink.c:457
main external API structure.
Definition: avcodec.h:1339
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1365
op_fill_func fill_block_tab[2]
Definition: dsputil.h:489
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:418
static av_cold int decode_init(AVCodecContext *avctx)
Definition: bink.c:1269
int extradata_size
Definition: avcodec.h:1455
#define INIT_VLC_LE
Definition: get_bits.h:432
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
static const int32_t bink_intra_quant[16][64]
Definition: binkdata.h:288
DC values for interblocks with DCT.
Definition: bink.c:49
Sources
IDs for different data types used in Bink video codec.
Definition: bink.c:71
block is filled with two colours following custom pattern
Definition: bink.c:137
static int32_t binkb_intra_quant[16][64]
Definition: bink.c:65
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:372
8x8 block types
Definition: bink.c:43
static int read_residue(GetBitContext *gb, DCTELEM block[64], int masks_count)
Read 8x8 block with residue after motion compensation.
Definition: bink.c:702
static const uint8_t binkb_num[16]
Definition: binkdata.h:647
void ff_binkdsp_init(BinkDSPContext *c)
Definition: binkdsp.c:131
#define GET_HUFF(gb, tree)
Definition: bink.c:93
run lengths for special fill block
Definition: bink.c:80
short DCTELEM
Definition: dsputil.h:39
Y components of motion value.
Definition: bink.c:77
static VLC bink_trees[16]
Definition: bink.c:37
struct Bundle Bundle
data structure used for decoding single Bink data type
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:208
const uint8_t * quant
Bundle bundle[BINKB_NB_SRC]
bundles for decoding all data types
Definition: bink.c:120
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
pixel values used for different block types
Definition: bink.c:74
void(* idct_add)(uint8_t *dest, int line_size, int32_t *block)
Definition: binkdsp.h:34
X components of motion value.
Definition: bink.c:76
uint8_t * cur_ptr
pointer to the data that is not read from buffer yet
Definition: bink.c:105
#define BINK_FLAG_ALPHA
Definition: bink.c:34
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:65
static int binkb_read_bundle(BinkContext *c, GetBitContext *gb, int bundle_num)
Definition: bink.c:538
common internal api header.
static void init_lengths(BinkContext *c, int width, int bw)
Initialize length length in all bundles.
Definition: bink.c:148
static int read_colors(GetBitContext *gb, Bundle *b, BinkContext *c)
Definition: bink.c:418
static int read_block_types(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
Definition: bink.c:363
static void read_tree(GetBitContext *gb, Tree *tree)
Read information about Huffman tree used to decode data.
Definition: bink.c:235
static void binkb_init_bundles(BinkContext *c)
Definition: bink.c:531
uint8_t syms[16]
leaf value to symbol mapping
Definition: bink.c:90
static int read_dcs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b, int start_bits, int has_sign)
Definition: bink.c:459
AVFrame last
Definition: bink.c:115
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
Definition: bink.c:1167
DSP utils.
DC values for intrablocks with DCT.
Definition: bink.c:48
void * priv_data
Definition: avcodec.h:1382
static int read_motion_values(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
Definition: bink.c:329
struct BinkContext BinkContext
motion block with some difference added
Definition: bink.c:133
int len
static int binkb_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx, int is_key, int is_chroma)
Definition: bink.c:797
#define av_log2
Definition: intmath.h:85
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
void(* idct_put)(uint8_t *dest, int line_size, int32_t *block)
Definition: binkdsp.h:33
static const int binkb_bundle_sizes[BINKB_NB_SRC]
Definition: bink.c:57
int version
internal Bink file version
Definition: bink.c:116
static const int binkb_bundle_signed[BINKB_NB_SRC]
Definition: bink.c:61
static av_cold int decode_end(AVCodecContext *avctx)
Definition: bink.c:1321
static void read_bundle(GetBitContext *gb, BinkContext *c, int bundle_num)
Prepare bundle for decoding data.
Definition: bink.c:276
static const uint8_t bink_rlelens[4]
Definition: bink.c:361
DSPContext dsp
Definition: bink.c:113
pixel values used for different block types
Definition: bink.c:44
static int get_value(BinkContext *c, int bundle)
Retrieve next value from bundle.
Definition: bink.c:511
This structure stores compressed data.
Definition: avcodec.h:898
DC values for intrablocks with DCT.
Definition: bink.c:78
OldSources
IDs for different data types used in old version of Bink video codec.
Definition: bink.c:42
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:908
DSPContext.
Definition: dsputil.h:194
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)