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 "mathops.h"
29 
30 #define BITSTREAM_READER_LE
31 #include "get_bits.h"
32 
33 #define BINK_FLAG_ALPHA 0x00100000
34 #define BINK_FLAG_GRAY 0x00020000
35 
36 static VLC bink_trees[16];
37 
41 enum OldSources {
52 
54 };
55 
56 static const int binkb_bundle_sizes[BINKB_NB_SRC] = {
57  4, 8, 8, 5, 5, 11, 11, 4, 4, 7
58 };
59 
60 static const int binkb_bundle_signed[BINKB_NB_SRC] = {
61  0, 0, 0, 1, 1, 0, 1, 0, 0, 0
62 };
63 
64 static int32_t binkb_intra_quant[16][64];
65 static int32_t binkb_inter_quant[16][64];
66 
70 enum Sources {
80 
82 };
83 
87 typedef struct Tree {
88  int vlc_num;
89  uint8_t syms[16];
90 } Tree;
91 
92 #define GET_HUFF(gb, tree) (tree).syms[get_vlc2(gb, bink_trees[(tree).vlc_num].table,\
93  bink_trees[(tree).vlc_num].bits, 1)]
94 
98 typedef struct Bundle {
99  int len;
101  uint8_t *data;
102  uint8_t *data_end;
103  uint8_t *cur_dec;
104  uint8_t *cur_ptr;
105 } Bundle;
106 
107 /*
108  * Decoder context
109  */
110 typedef struct BinkContext {
115  int version;
118 
122 } BinkContext;
123 
138 };
139 
147 static void init_lengths(BinkContext *c, int width, int bw)
148 {
149  c->bundle[BINK_SRC_BLOCK_TYPES].len = av_log2((width >> 3) + 511) + 1;
150 
151  c->bundle[BINK_SRC_SUB_BLOCK_TYPES].len = av_log2((width >> 4) + 511) + 1;
152 
153  c->bundle[BINK_SRC_COLORS].len = av_log2(bw*64 + 511) + 1;
154 
158  c->bundle[BINK_SRC_Y_OFF].len = av_log2((width >> 3) + 511) + 1;
159 
160  c->bundle[BINK_SRC_PATTERN].len = av_log2((bw << 3) + 511) + 1;
161 
162  c->bundle[BINK_SRC_RUN].len = av_log2(bw*48 + 511) + 1;
163 }
164 
171 {
172  int bw, bh, blocks;
173  int i;
174 
175  bw = (c->avctx->width + 7) >> 3;
176  bh = (c->avctx->height + 7) >> 3;
177  blocks = bw * bh;
178 
179  for (i = 0; i < BINKB_NB_SRC; i++) {
180  c->bundle[i].data = av_malloc(blocks * 64);
181  c->bundle[i].data_end = c->bundle[i].data + blocks * 64;
182  }
183 }
184 
191 {
192  int i;
193  for (i = 0; i < BINKB_NB_SRC; i++)
194  av_freep(&c->bundle[i].data);
195 }
196 
205 static void merge(GetBitContext *gb, uint8_t *dst, uint8_t *src, int size)
206 {
207  uint8_t *src2 = src + size;
208  int size2 = size;
209 
210  do {
211  if (!get_bits1(gb)) {
212  *dst++ = *src++;
213  size--;
214  } else {
215  *dst++ = *src2++;
216  size2--;
217  }
218  } while (size && size2);
219 
220  while (size--)
221  *dst++ = *src++;
222  while (size2--)
223  *dst++ = *src2++;
224 }
225 
232 static void read_tree(GetBitContext *gb, Tree *tree)
233 {
234  uint8_t tmp1[16], tmp2[16], *in = tmp1, *out = tmp2;
235  int i, t, len;
236 
237  tree->vlc_num = get_bits(gb, 4);
238  if (!tree->vlc_num) {
239  for (i = 0; i < 16; i++)
240  tree->syms[i] = i;
241  return;
242  }
243  if (get_bits1(gb)) {
244  len = get_bits(gb, 3);
245  memset(tmp1, 0, sizeof(tmp1));
246  for (i = 0; i <= len; i++) {
247  tree->syms[i] = get_bits(gb, 4);
248  tmp1[tree->syms[i]] = 1;
249  }
250  for (i = 0; i < 16 && len < 16 - 1; i++)
251  if (!tmp1[i])
252  tree->syms[++len] = i;
253  } else {
254  len = get_bits(gb, 2);
255  for (i = 0; i < 16; i++)
256  in[i] = i;
257  for (i = 0; i <= len; i++) {
258  int size = 1 << i;
259  for (t = 0; t < 16; t += size << 1)
260  merge(gb, out + t, in + t, size);
261  FFSWAP(uint8_t*, in, out);
262  }
263  memcpy(tree->syms, in, 16);
264  }
265 }
266 
274 static void read_bundle(GetBitContext *gb, BinkContext *c, int bundle_num)
275 {
276  int i;
277 
278  if (bundle_num == BINK_SRC_COLORS) {
279  for (i = 0; i < 16; i++)
280  read_tree(gb, &c->col_high[i]);
281  c->col_lastval = 0;
282  }
283  if (bundle_num != BINK_SRC_INTRA_DC && bundle_num != BINK_SRC_INTER_DC)
284  read_tree(gb, &c->bundle[bundle_num].tree);
285  c->bundle[bundle_num].cur_dec =
286  c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data;
287 }
288 
296 #define CHECK_READ_VAL(gb, b, t) \
297  if (!b->cur_dec || (b->cur_dec > b->cur_ptr)) \
298  return 0; \
299  t = get_bits(gb, b->len); \
300  if (!t) { \
301  b->cur_dec = NULL; \
302  return 0; \
303  } \
304 
305 static int read_runs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b)
306 {
307  int t, v;
308  const uint8_t *dec_end;
309 
310  CHECK_READ_VAL(gb, b, t);
311  dec_end = b->cur_dec + t;
312  if (dec_end > b->data_end) {
313  av_log(avctx, AV_LOG_ERROR, "Run value went out of bounds\n");
314  return -1;
315  }
316  if (get_bits1(gb)) {
317  v = get_bits(gb, 4);
318  memset(b->cur_dec, v, t);
319  b->cur_dec += t;
320  } else {
321  while (b->cur_dec < dec_end)
322  *b->cur_dec++ = GET_HUFF(gb, b->tree);
323  }
324  return 0;
325 }
326 
328 {
329  int t, sign, v;
330  const uint8_t *dec_end;
331 
332  CHECK_READ_VAL(gb, b, t);
333  dec_end = b->cur_dec + t;
334  if (dec_end > b->data_end) {
335  av_log(avctx, AV_LOG_ERROR, "Too many motion values\n");
336  return -1;
337  }
338  if (get_bits1(gb)) {
339  v = get_bits(gb, 4);
340  if (v) {
341  sign = -get_bits1(gb);
342  v = (v ^ sign) - sign;
343  }
344  memset(b->cur_dec, v, t);
345  b->cur_dec += t;
346  } else {
347  while (b->cur_dec < dec_end) {
348  v = GET_HUFF(gb, b->tree);
349  if (v) {
350  sign = -get_bits1(gb);
351  v = (v ^ sign) - sign;
352  }
353  *b->cur_dec++ = v;
354  }
355  }
356  return 0;
357 }
358 
359 static const uint8_t bink_rlelens[4] = { 4, 8, 12, 32 };
360 
362 {
363  int t, v;
364  int last = 0;
365  const uint8_t *dec_end;
366 
367  CHECK_READ_VAL(gb, b, t);
368  dec_end = b->cur_dec + t;
369  if (dec_end > b->data_end) {
370  av_log(avctx, AV_LOG_ERROR, "Too many block type values\n");
371  return -1;
372  }
373  if (get_bits1(gb)) {
374  v = get_bits(gb, 4);
375  memset(b->cur_dec, v, t);
376  b->cur_dec += t;
377  } else {
378  while (b->cur_dec < dec_end) {
379  v = GET_HUFF(gb, b->tree);
380  if (v < 12) {
381  last = v;
382  *b->cur_dec++ = v;
383  } else {
384  int run = bink_rlelens[v - 12];
385 
386  if (dec_end - b->cur_dec < run)
387  return -1;
388  memset(b->cur_dec, last, run);
389  b->cur_dec += run;
390  }
391  }
392  }
393  return 0;
394 }
395 
397 {
398  int t, v;
399  const uint8_t *dec_end;
400 
401  CHECK_READ_VAL(gb, b, t);
402  dec_end = b->cur_dec + t;
403  if (dec_end > b->data_end) {
404  av_log(avctx, AV_LOG_ERROR, "Too many pattern values\n");
405  return -1;
406  }
407  while (b->cur_dec < dec_end) {
408  v = GET_HUFF(gb, b->tree);
409  v |= GET_HUFF(gb, b->tree) << 4;
410  *b->cur_dec++ = v;
411  }
412 
413  return 0;
414 }
415 
417 {
418  int t, sign, v;
419  const uint8_t *dec_end;
420 
421  CHECK_READ_VAL(gb, b, t);
422  dec_end = b->cur_dec + t;
423  if (dec_end > b->data_end) {
424  av_log(c->avctx, AV_LOG_ERROR, "Too many color values\n");
425  return -1;
426  }
427  if (get_bits1(gb)) {
428  c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]);
429  v = GET_HUFF(gb, b->tree);
430  v = (c->col_lastval << 4) | v;
431  if (c->version < 'i') {
432  sign = ((int8_t) v) >> 7;
433  v = ((v & 0x7F) ^ sign) - sign;
434  v += 0x80;
435  }
436  memset(b->cur_dec, v, t);
437  b->cur_dec += t;
438  } else {
439  while (b->cur_dec < dec_end) {
440  c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]);
441  v = GET_HUFF(gb, b->tree);
442  v = (c->col_lastval << 4) | v;
443  if (c->version < 'i') {
444  sign = ((int8_t) v) >> 7;
445  v = ((v & 0x7F) ^ sign) - sign;
446  v += 0x80;
447  }
448  *b->cur_dec++ = v;
449  }
450  }
451  return 0;
452 }
453 
455 #define DC_START_BITS 11
456 
457 static int read_dcs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b,
458  int start_bits, int has_sign)
459 {
460  int i, j, len, len2, bsize, sign, v, v2;
461  int16_t *dst = (int16_t*)b->cur_dec;
462  int16_t *dst_end = (int16_t*)b->data_end;
463 
464  CHECK_READ_VAL(gb, b, len);
465  v = get_bits(gb, start_bits - has_sign);
466  if (v && has_sign) {
467  sign = -get_bits1(gb);
468  v = (v ^ sign) - sign;
469  }
470  if (dst_end - dst < 1)
471  return -1;
472  *dst++ = v;
473  len--;
474  for (i = 0; i < len; i += 8) {
475  len2 = FFMIN(len - i, 8);
476  if (dst_end - dst < len2)
477  return -1;
478  bsize = get_bits(gb, 4);
479  if (bsize) {
480  for (j = 0; j < len2; j++) {
481  v2 = get_bits(gb, bsize);
482  if (v2) {
483  sign = -get_bits1(gb);
484  v2 = (v2 ^ sign) - sign;
485  }
486  v += v2;
487  *dst++ = v;
488  if (v < -32768 || v > 32767) {
489  av_log(avctx, AV_LOG_ERROR, "DC value went out of bounds: %d\n", v);
490  return -1;
491  }
492  }
493  } else {
494  for (j = 0; j < len2; j++)
495  *dst++ = v;
496  }
497  }
498 
499  b->cur_dec = (uint8_t*)dst;
500  return 0;
501 }
502 
509 static inline int get_value(BinkContext *c, int bundle)
510 {
511  int ret;
512 
513  if (bundle < BINK_SRC_X_OFF || bundle == BINK_SRC_RUN)
514  return *c->bundle[bundle].cur_ptr++;
515  if (bundle == BINK_SRC_X_OFF || bundle == BINK_SRC_Y_OFF)
516  return (int8_t)*c->bundle[bundle].cur_ptr++;
517  ret = *(int16_t*)c->bundle[bundle].cur_ptr;
518  c->bundle[bundle].cur_ptr += 2;
519  return ret;
520 }
521 
522 static void binkb_init_bundle(BinkContext *c, int bundle_num)
523 {
524  c->bundle[bundle_num].cur_dec =
525  c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data;
526  c->bundle[bundle_num].len = 13;
527 }
528 
530 {
531  int i;
532  for (i = 0; i < BINKB_NB_SRC; i++)
533  binkb_init_bundle(c, i);
534 }
535 
536 static int binkb_read_bundle(BinkContext *c, GetBitContext *gb, int bundle_num)
537 {
538  const int bits = binkb_bundle_sizes[bundle_num];
539  const int mask = 1 << (bits - 1);
540  const int issigned = binkb_bundle_signed[bundle_num];
541  Bundle *b = &c->bundle[bundle_num];
542  int i, len;
543 
544  CHECK_READ_VAL(gb, b, len);
545  if (b->data_end - b->cur_dec < len * (1 + (bits > 8)))
546  return -1;
547  if (bits <= 8) {
548  if (!issigned) {
549  for (i = 0; i < len; i++)
550  *b->cur_dec++ = get_bits(gb, bits);
551  } else {
552  for (i = 0; i < len; i++)
553  *b->cur_dec++ = get_bits(gb, bits) - mask;
554  }
555  } else {
556  int16_t *dst = (int16_t*)b->cur_dec;
557 
558  if (!issigned) {
559  for (i = 0; i < len; i++)
560  *dst++ = get_bits(gb, bits);
561  } else {
562  for (i = 0; i < len; i++)
563  *dst++ = get_bits(gb, bits) - mask;
564  }
565  b->cur_dec = (uint8_t*)dst;
566  }
567  return 0;
568 }
569 
570 static inline int binkb_get_value(BinkContext *c, int bundle_num)
571 {
572  int16_t ret;
573  const int bits = binkb_bundle_sizes[bundle_num];
574 
575  if (bits <= 8) {
576  int val = *c->bundle[bundle_num].cur_ptr++;
577  return binkb_bundle_signed[bundle_num] ? (int8_t)val : val;
578  }
579  ret = *(int16_t*)c->bundle[bundle_num].cur_ptr;
580  c->bundle[bundle_num].cur_ptr += 2;
581  return ret;
582 }
583 
593 static int read_dct_coeffs(GetBitContext *gb, int32_t block[64], const uint8_t *scan,
594  const int32_t quant_matrices[16][64], int q)
595 {
596  int coef_list[128];
597  int mode_list[128];
598  int i, t, bits, ccoef, mode, sign;
599  int list_start = 64, list_end = 64, list_pos;
600  int coef_count = 0;
601  int coef_idx[64];
602  int quant_idx;
603  const int32_t *quant;
604 
605  coef_list[list_end] = 4; mode_list[list_end++] = 0;
606  coef_list[list_end] = 24; mode_list[list_end++] = 0;
607  coef_list[list_end] = 44; mode_list[list_end++] = 0;
608  coef_list[list_end] = 1; mode_list[list_end++] = 3;
609  coef_list[list_end] = 2; mode_list[list_end++] = 3;
610  coef_list[list_end] = 3; mode_list[list_end++] = 3;
611 
612  for (bits = get_bits(gb, 4) - 1; bits >= 0; bits--) {
613  list_pos = list_start;
614  while (list_pos < list_end) {
615  if (!(mode_list[list_pos] | coef_list[list_pos]) || !get_bits1(gb)) {
616  list_pos++;
617  continue;
618  }
619  ccoef = coef_list[list_pos];
620  mode = mode_list[list_pos];
621  switch (mode) {
622  case 0:
623  coef_list[list_pos] = ccoef + 4;
624  mode_list[list_pos] = 1;
625  case 2:
626  if (mode == 2) {
627  coef_list[list_pos] = 0;
628  mode_list[list_pos++] = 0;
629  }
630  for (i = 0; i < 4; i++, ccoef++) {
631  if (get_bits1(gb)) {
632  coef_list[--list_start] = ccoef;
633  mode_list[ list_start] = 3;
634  } else {
635  if (!bits) {
636  t = 1 - (get_bits1(gb) << 1);
637  } else {
638  t = get_bits(gb, bits) | 1 << bits;
639  sign = -get_bits1(gb);
640  t = (t ^ sign) - sign;
641  }
642  block[scan[ccoef]] = t;
643  coef_idx[coef_count++] = ccoef;
644  }
645  }
646  break;
647  case 1:
648  mode_list[list_pos] = 2;
649  for (i = 0; i < 3; i++) {
650  ccoef += 4;
651  coef_list[list_end] = ccoef;
652  mode_list[list_end++] = 2;
653  }
654  break;
655  case 3:
656  if (!bits) {
657  t = 1 - (get_bits1(gb) << 1);
658  } else {
659  t = get_bits(gb, bits) | 1 << bits;
660  sign = -get_bits1(gb);
661  t = (t ^ sign) - sign;
662  }
663  block[scan[ccoef]] = t;
664  coef_idx[coef_count++] = ccoef;
665  coef_list[list_pos] = 0;
666  mode_list[list_pos++] = 0;
667  break;
668  }
669  }
670  }
671 
672  if (q == -1) {
673  quant_idx = get_bits(gb, 4);
674  } else {
675  quant_idx = q;
676  }
677 
678  if (quant_idx >= 16)
679  return AVERROR_INVALIDDATA;
680 
681  quant = quant_matrices[quant_idx];
682 
683  block[0] = (block[0] * quant[0]) >> 11;
684  for (i = 0; i < coef_count; i++) {
685  int idx = coef_idx[i];
686  block[scan[idx]] = (block[scan[idx]] * quant[idx]) >> 11;
687  }
688 
689  return 0;
690 }
691 
700 static int read_residue(GetBitContext *gb, DCTELEM block[64], int masks_count)
701 {
702  int coef_list[128];
703  int mode_list[128];
704  int i, sign, mask, ccoef, mode;
705  int list_start = 64, list_end = 64, list_pos;
706  int nz_coeff[64];
707  int nz_coeff_count = 0;
708 
709  coef_list[list_end] = 4; mode_list[list_end++] = 0;
710  coef_list[list_end] = 24; mode_list[list_end++] = 0;
711  coef_list[list_end] = 44; mode_list[list_end++] = 0;
712  coef_list[list_end] = 0; mode_list[list_end++] = 2;
713 
714  for (mask = 1 << get_bits(gb, 3); mask; mask >>= 1) {
715  for (i = 0; i < nz_coeff_count; i++) {
716  if (!get_bits1(gb))
717  continue;
718  if (block[nz_coeff[i]] < 0)
719  block[nz_coeff[i]] -= mask;
720  else
721  block[nz_coeff[i]] += mask;
722  masks_count--;
723  if (masks_count < 0)
724  return 0;
725  }
726  list_pos = list_start;
727  while (list_pos < list_end) {
728  if (!(coef_list[list_pos] | mode_list[list_pos]) || !get_bits1(gb)) {
729  list_pos++;
730  continue;
731  }
732  ccoef = coef_list[list_pos];
733  mode = mode_list[list_pos];
734  switch (mode) {
735  case 0:
736  coef_list[list_pos] = ccoef + 4;
737  mode_list[list_pos] = 1;
738  case 2:
739  if (mode == 2) {
740  coef_list[list_pos] = 0;
741  mode_list[list_pos++] = 0;
742  }
743  for (i = 0; i < 4; i++, ccoef++) {
744  if (get_bits1(gb)) {
745  coef_list[--list_start] = ccoef;
746  mode_list[ list_start] = 3;
747  } else {
748  nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
749  sign = -get_bits1(gb);
750  block[bink_scan[ccoef]] = (mask ^ sign) - sign;
751  masks_count--;
752  if (masks_count < 0)
753  return 0;
754  }
755  }
756  break;
757  case 1:
758  mode_list[list_pos] = 2;
759  for (i = 0; i < 3; i++) {
760  ccoef += 4;
761  coef_list[list_end] = ccoef;
762  mode_list[list_end++] = 2;
763  }
764  break;
765  case 3:
766  nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
767  sign = -get_bits1(gb);
768  block[bink_scan[ccoef]] = (mask ^ sign) - sign;
769  coef_list[list_pos] = 0;
770  mode_list[list_pos++] = 0;
771  masks_count--;
772  if (masks_count < 0)
773  return 0;
774  break;
775  }
776  }
777  }
778 
779  return 0;
780 }
781 
785 static inline void put_pixels8x8_overlapped(uint8_t *dst, uint8_t *src, int stride)
786 {
787  uint8_t tmp[64];
788  int i;
789  for (i = 0; i < 8; i++)
790  memcpy(tmp + i*8, src + i*stride, 8);
791  for (i = 0; i < 8; i++)
792  memcpy(dst + i*stride, tmp + i*8, 8);
793 }
794 
795 static int binkb_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
796  int is_key, int is_chroma)
797 {
798  int blk;
799  int i, j, bx, by;
800  uint8_t *dst, *ref, *ref_start, *ref_end;
801  int v, col[2];
802  const uint8_t *scan;
803  int xoff, yoff;
805  LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
806  int coordmap[64];
807  int ybias = is_key ? -15 : 0;
808  int qp;
809 
810  const int stride = c->pic.linesize[plane_idx];
811  int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3;
812  int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
813 
815  ref_start = c->pic.data[plane_idx];
816  ref_end = c->pic.data[plane_idx] + (bh * c->pic.linesize[plane_idx] + bw) * 8;
817 
818  for (i = 0; i < 64; i++)
819  coordmap[i] = (i & 7) + (i >> 3) * stride;
820 
821  for (by = 0; by < bh; by++) {
822  for (i = 0; i < BINKB_NB_SRC; i++) {
823  if (binkb_read_bundle(c, gb, i) < 0)
824  return -1;
825  }
826 
827  dst = c->pic.data[plane_idx] + 8*by*stride;
828  for (bx = 0; bx < bw; bx++, dst += 8) {
830  switch (blk) {
831  case 0:
832  break;
833  case 1:
834  scan = bink_patterns[get_bits(gb, 4)];
835  i = 0;
836  do {
837  int mode, run;
838 
839  mode = get_bits1(gb);
840  run = get_bits(gb, binkb_runbits[i]) + 1;
841 
842  i += run;
843  if (i > 64) {
844  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
845  return -1;
846  }
847  if (mode) {
849  for (j = 0; j < run; j++)
850  dst[coordmap[*scan++]] = v;
851  } else {
852  for (j = 0; j < run; j++)
853  dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
854  }
855  } while (i < 63);
856  if (i == 63)
857  dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
858  break;
859  case 2:
860  memset(dctblock, 0, sizeof(*dctblock) * 64);
861  dctblock[0] = binkb_get_value(c, BINKB_SRC_INTRA_DC);
863  read_dct_coeffs(gb, dctblock, bink_scan, binkb_intra_quant, qp);
864  c->bdsp.idct_put(dst, stride, dctblock);
865  break;
866  case 3:
867  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
868  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
869  ref = dst + xoff + yoff * stride;
870  if (ref < ref_start || ref + 8*stride > ref_end) {
871  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
872  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
873  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
874  } else {
875  put_pixels8x8_overlapped(dst, ref, stride);
876  }
877  c->dsp.clear_block(block);
879  read_residue(gb, block, v);
880  c->dsp.add_pixels8(dst, block, stride);
881  break;
882  case 4:
883  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
884  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
885  ref = dst + xoff + yoff * stride;
886  if (ref < ref_start || ref + 8 * stride > ref_end) {
887  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
888  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
889  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
890  } else {
891  put_pixels8x8_overlapped(dst, ref, stride);
892  }
893  memset(dctblock, 0, sizeof(*dctblock) * 64);
894  dctblock[0] = binkb_get_value(c, BINKB_SRC_INTER_DC);
896  read_dct_coeffs(gb, dctblock, bink_scan, binkb_inter_quant, qp);
897  c->bdsp.idct_add(dst, stride, dctblock);
898  break;
899  case 5:
901  c->dsp.fill_block_tab[1](dst, v, stride, 8);
902  break;
903  case 6:
904  for (i = 0; i < 2; i++)
905  col[i] = binkb_get_value(c, BINKB_SRC_COLORS);
906  for (i = 0; i < 8; i++) {
908  for (j = 0; j < 8; j++, v >>= 1)
909  dst[i*stride + j] = col[v & 1];
910  }
911  break;
912  case 7:
913  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
914  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
915  ref = dst + xoff + yoff * stride;
916  if (ref < ref_start || ref + 8 * stride > ref_end) {
917  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
918  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
919  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
920  } else {
921  put_pixels8x8_overlapped(dst, ref, stride);
922  }
923  break;
924  case 8:
925  for (i = 0; i < 8; i++)
926  memcpy(dst + i*stride, c->bundle[BINKB_SRC_COLORS].cur_ptr + i*8, 8);
927  c->bundle[BINKB_SRC_COLORS].cur_ptr += 64;
928  break;
929  default:
930  av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
931  return -1;
932  }
933  }
934  }
935  if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary
936  skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
937 
938  return 0;
939 }
940 
941 static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
942  int is_chroma)
943 {
944  int blk;
945  int i, j, bx, by;
946  uint8_t *dst, *prev, *ref, *ref_start, *ref_end;
947  int v, col[2];
948  const uint8_t *scan;
949  int xoff, yoff;
951  LOCAL_ALIGNED_16(uint8_t, ublock, [64]);
952  LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
953  int coordmap[64];
954 
955  const int stride = c->pic.linesize[plane_idx];
956  int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3;
957  int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
958  int width = c->avctx->width >> is_chroma;
959 
960  init_lengths(c, FFMAX(width, 8), bw);
961  for (i = 0; i < BINK_NB_SRC; i++)
962  read_bundle(gb, c, i);
963 
964  ref_start = c->last.data[plane_idx] ? c->last.data[plane_idx]
965  : c->pic.data[plane_idx];
966  ref_end = ref_start
967  + (bw - 1 + c->last.linesize[plane_idx] * (bh - 1)) * 8;
968 
969  for (i = 0; i < 64; i++)
970  coordmap[i] = (i & 7) + (i >> 3) * stride;
971 
972  for (by = 0; by < bh; by++) {
973  if (read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0)
974  return -1;
976  return -1;
977  if (read_colors(gb, &c->bundle[BINK_SRC_COLORS], c) < 0)
978  return -1;
979  if (read_patterns(c->avctx, gb, &c->bundle[BINK_SRC_PATTERN]) < 0)
980  return -1;
981  if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_X_OFF]) < 0)
982  return -1;
983  if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_Y_OFF]) < 0)
984  return -1;
985  if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0)
986  return -1;
987  if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0)
988  return -1;
989  if (read_runs(c->avctx, gb, &c->bundle[BINK_SRC_RUN]) < 0)
990  return -1;
991 
992  if (by == bh)
993  break;
994  dst = c->pic.data[plane_idx] + 8*by*stride;
995  prev = (c->last.data[plane_idx] ? c->last.data[plane_idx]
996  : c->pic.data[plane_idx]) + 8*by*stride;
997  for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) {
999  // 16x16 block type on odd line means part of the already decoded block, so skip it
1000  if ((by & 1) && blk == SCALED_BLOCK) {
1001  bx++;
1002  dst += 8;
1003  prev += 8;
1004  continue;
1005  }
1006  switch (blk) {
1007  case SKIP_BLOCK:
1008  c->dsp.put_pixels_tab[1][0](dst, prev, stride, 8);
1009  break;
1010  case SCALED_BLOCK:
1012  switch (blk) {
1013  case RUN_BLOCK:
1014  scan = bink_patterns[get_bits(gb, 4)];
1015  i = 0;
1016  do {
1017  int run = get_value(c, BINK_SRC_RUN) + 1;
1018 
1019  i += run;
1020  if (i > 64) {
1021  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
1022  return -1;
1023  }
1024  if (get_bits1(gb)) {
1025  v = get_value(c, BINK_SRC_COLORS);
1026  for (j = 0; j < run; j++)
1027  ublock[*scan++] = v;
1028  } else {
1029  for (j = 0; j < run; j++)
1030  ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
1031  }
1032  } while (i < 63);
1033  if (i == 63)
1034  ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
1035  break;
1036  case INTRA_BLOCK:
1037  memset(dctblock, 0, sizeof(*dctblock) * 64);
1038  dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
1039  read_dct_coeffs(gb, dctblock, bink_scan, bink_intra_quant, -1);
1040  c->bdsp.idct_put(ublock, 8, dctblock);
1041  break;
1042  case FILL_BLOCK:
1043  v = get_value(c, BINK_SRC_COLORS);
1044  c->dsp.fill_block_tab[0](dst, v, stride, 16);
1045  break;
1046  case PATTERN_BLOCK:
1047  for (i = 0; i < 2; i++)
1048  col[i] = get_value(c, BINK_SRC_COLORS);
1049  for (j = 0; j < 8; j++) {
1050  v = get_value(c, BINK_SRC_PATTERN);
1051  for (i = 0; i < 8; i++, v >>= 1)
1052  ublock[i + j*8] = col[v & 1];
1053  }
1054  break;
1055  case RAW_BLOCK:
1056  for (j = 0; j < 8; j++)
1057  for (i = 0; i < 8; i++)
1058  ublock[i + j*8] = get_value(c, BINK_SRC_COLORS);
1059  break;
1060  default:
1061  av_log(c->avctx, AV_LOG_ERROR, "Incorrect 16x16 block type %d\n", blk);
1062  return -1;
1063  }
1064  if (blk != FILL_BLOCK)
1065  c->bdsp.scale_block(ublock, dst, stride);
1066  bx++;
1067  dst += 8;
1068  prev += 8;
1069  break;
1070  case MOTION_BLOCK:
1071  xoff = get_value(c, BINK_SRC_X_OFF);
1072  yoff = get_value(c, BINK_SRC_Y_OFF);
1073  ref = prev + xoff + yoff * stride;
1074  if (ref < ref_start || ref > ref_end) {
1075  av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
1076  bx*8 + xoff, by*8 + yoff);
1077  return -1;
1078  }
1079  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
1080  break;
1081  case RUN_BLOCK:
1082  scan = bink_patterns[get_bits(gb, 4)];
1083  i = 0;
1084  do {
1085  int run = get_value(c, BINK_SRC_RUN) + 1;
1086 
1087  i += run;
1088  if (i > 64) {
1089  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
1090  return -1;
1091  }
1092  if (get_bits1(gb)) {
1093  v = get_value(c, BINK_SRC_COLORS);
1094  for (j = 0; j < run; j++)
1095  dst[coordmap[*scan++]] = v;
1096  } else {
1097  for (j = 0; j < run; j++)
1098  dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
1099  }
1100  } while (i < 63);
1101  if (i == 63)
1102  dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
1103  break;
1104  case RESIDUE_BLOCK:
1105  xoff = get_value(c, BINK_SRC_X_OFF);
1106  yoff = get_value(c, BINK_SRC_Y_OFF);
1107  ref = prev + xoff + yoff * stride;
1108  if (ref < ref_start || ref > ref_end) {
1109  av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
1110  bx*8 + xoff, by*8 + yoff);
1111  return -1;
1112  }
1113  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
1114  c->dsp.clear_block(block);
1115  v = get_bits(gb, 7);
1116  read_residue(gb, block, v);
1117  c->dsp.add_pixels8(dst, block, stride);
1118  break;
1119  case INTRA_BLOCK:
1120  memset(dctblock, 0, sizeof(*dctblock) * 64);
1121  dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
1122  read_dct_coeffs(gb, dctblock, bink_scan, bink_intra_quant, -1);
1123  c->bdsp.idct_put(dst, stride, dctblock);
1124  break;
1125  case FILL_BLOCK:
1126  v = get_value(c, BINK_SRC_COLORS);
1127  c->dsp.fill_block_tab[1](dst, v, stride, 8);
1128  break;
1129  case INTER_BLOCK:
1130  xoff = get_value(c, BINK_SRC_X_OFF);
1131  yoff = get_value(c, BINK_SRC_Y_OFF);
1132  ref = prev + xoff + yoff * stride;
1133  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
1134  memset(dctblock, 0, sizeof(*dctblock) * 64);
1135  dctblock[0] = get_value(c, BINK_SRC_INTER_DC);
1136  read_dct_coeffs(gb, dctblock, bink_scan, bink_inter_quant, -1);
1137  c->bdsp.idct_add(dst, stride, dctblock);
1138  break;
1139  case PATTERN_BLOCK:
1140  for (i = 0; i < 2; i++)
1141  col[i] = get_value(c, BINK_SRC_COLORS);
1142  for (i = 0; i < 8; i++) {
1143  v = get_value(c, BINK_SRC_PATTERN);
1144  for (j = 0; j < 8; j++, v >>= 1)
1145  dst[i*stride + j] = col[v & 1];
1146  }
1147  break;
1148  case RAW_BLOCK:
1149  for (i = 0; i < 8; i++)
1150  memcpy(dst + i*stride, c->bundle[BINK_SRC_COLORS].cur_ptr + i*8, 8);
1151  c->bundle[BINK_SRC_COLORS].cur_ptr += 64;
1152  break;
1153  default:
1154  av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
1155  return -1;
1156  }
1157  }
1158  }
1159  if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary
1160  skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
1161 
1162  return 0;
1163 }
1164 
1165 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt)
1166 {
1167  BinkContext * const c = avctx->priv_data;
1168  GetBitContext gb;
1169  int plane, plane_idx;
1170  int bits_count = pkt->size << 3;
1171 
1172  if (c->version > 'b') {
1173  if(c->pic.data[0])
1174  avctx->release_buffer(avctx, &c->pic);
1175 
1176  if(avctx->get_buffer(avctx, &c->pic) < 0){
1177  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1178  return -1;
1179  }
1180  } else {
1181  if(avctx->reget_buffer(avctx, &c->pic) < 0){
1182  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1183  return -1;
1184  }
1185  }
1186 
1187  init_get_bits(&gb, pkt->data, bits_count);
1188  if (c->has_alpha) {
1189  if (c->version >= 'i')
1190  skip_bits_long(&gb, 32);
1191  if (bink_decode_plane(c, &gb, 3, 0) < 0)
1192  return -1;
1193  }
1194  if (c->version >= 'i')
1195  skip_bits_long(&gb, 32);
1196 
1197  for (plane = 0; plane < 3; plane++) {
1198  plane_idx = (!plane || !c->swap_planes) ? plane : (plane ^ 3);
1199 
1200  if (c->version > 'b') {
1201  if (bink_decode_plane(c, &gb, plane_idx, !!plane) < 0)
1202  return -1;
1203  } else {
1204  if (binkb_decode_plane(c, &gb, plane_idx, !pkt->pts, !!plane) < 0)
1205  return -1;
1206  }
1207  if (get_bits_count(&gb) >= bits_count)
1208  break;
1209  }
1210  emms_c();
1211 
1212  *data_size = sizeof(AVFrame);
1213  *(AVFrame*)data = c->pic;
1214 
1215  if (c->version > 'b')
1216  FFSWAP(AVFrame, c->pic, c->last);
1217 
1218  /* always report that the buffer was completely consumed */
1219  return pkt->size;
1220 }
1221 
1225 static av_cold void binkb_calc_quant(void)
1226 {
1227  uint8_t inv_bink_scan[64];
1228  double s[64];
1229  int i, j;
1230 
1231  for (j = 0; j < 8; j++) {
1232  for (i = 0; i < 8; i++) {
1233  if (j && j != 4)
1234  if (i && i != 4)
1235  s[j*8 + i] = cos(j * M_PI/16.0) * cos(i * M_PI/16.0) * 2.0;
1236  else
1237  s[j*8 + i] = cos(j * M_PI/16.0) * sqrt(2.0);
1238  else
1239  if (i && i != 4)
1240  s[j*8 + i] = cos(i * M_PI/16.0) * sqrt(2.0);
1241  else
1242  s[j*8 + i] = 1.0;
1243  }
1244  }
1245 
1246  for (i = 0; i < 64; i++)
1247  inv_bink_scan[bink_scan[i]] = i;
1248 
1249  for (j = 0; j < 16; j++) {
1250  for (i = 0; i < 64; i++) {
1251  int k = inv_bink_scan[i];
1252  if (s[i] == 1.0) {
1253  binkb_intra_quant[j][k] = (1L << 12) * binkb_intra_seed[i] *
1254  binkb_num[j]/binkb_den[j];
1255  binkb_inter_quant[j][k] = (1L << 12) * binkb_inter_seed[i] *
1256  binkb_num[j]/binkb_den[j];
1257  } else {
1258  binkb_intra_quant[j][k] = (1L << 12) * binkb_intra_seed[i] * s[i] *
1259  binkb_num[j]/(double)binkb_den[j];
1260  binkb_inter_quant[j][k] = (1L << 12) * binkb_inter_seed[i] * s[i] *
1261  binkb_num[j]/(double)binkb_den[j];
1262  }
1263  }
1264  }
1265 }
1266 
1268 {
1269  BinkContext * const c = avctx->priv_data;
1270  static VLC_TYPE table[16 * 128][2];
1271  static int binkb_initialised = 0;
1272  int i;
1273  int flags;
1274 
1275  c->version = avctx->codec_tag >> 24;
1276  if (avctx->extradata_size < 4) {
1277  av_log(avctx, AV_LOG_ERROR, "Extradata missing or too short\n");
1278  return -1;
1279  }
1280  flags = AV_RL32(avctx->extradata);
1281  c->has_alpha = flags & BINK_FLAG_ALPHA;
1282  c->swap_planes = c->version >= 'h';
1283  if (!bink_trees[15].table) {
1284  for (i = 0; i < 16; i++) {
1285  const int maxbits = bink_tree_lens[i][15];
1286  bink_trees[i].table = table + i*128;
1287  bink_trees[i].table_allocated = 1 << maxbits;
1288  init_vlc(&bink_trees[i], maxbits, 16,
1289  bink_tree_lens[i], 1, 1,
1291  }
1292  }
1293  c->avctx = avctx;
1294 
1295  c->pic.data[0] = NULL;
1296 
1297  if (av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0) {
1298  return 1;
1299  }
1300 
1302 
1303  avctx->idct_algo = FF_IDCT_BINK;
1304  dsputil_init(&c->dsp, avctx);
1305  ff_binkdsp_init(&c->bdsp);
1306 
1307  init_bundles(c);
1308 
1309  if (c->version == 'b') {
1310  if (!binkb_initialised) {
1311  binkb_calc_quant();
1312  binkb_initialised = 1;
1313  }
1314  }
1315 
1316  return 0;
1317 }
1318 
1320 {
1321  BinkContext * const c = avctx->priv_data;
1322 
1323  if (c->pic.data[0])
1324  avctx->release_buffer(avctx, &c->pic);
1325  if (c->last.data[0])
1326  avctx->release_buffer(avctx, &c->last);
1327 
1328  free_bundles(c);
1329  return 0;
1330 }
1331 
1333  .name = "binkvideo",
1334  .type = AVMEDIA_TYPE_VIDEO,
1335  .id = CODEC_ID_BINKVIDEO,
1336  .priv_data_size = sizeof(BinkContext),
1337  .init = decode_init,
1338  .close = decode_end,
1339  .decode = decode_frame,
1340  .long_name = NULL_IF_CONFIG_SMALL("Bink video"),
1341 };