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  quant = quant_matrices[quant_idx];
679 
680  block[0] = (block[0] * quant[0]) >> 11;
681  for (i = 0; i < coef_count; i++) {
682  int idx = coef_idx[i];
683  block[scan[idx]] = (block[scan[idx]] * quant[idx]) >> 11;
684  }
685 
686  return 0;
687 }
688 
697 static int read_residue(GetBitContext *gb, DCTELEM block[64], int masks_count)
698 {
699  int coef_list[128];
700  int mode_list[128];
701  int i, sign, mask, ccoef, mode;
702  int list_start = 64, list_end = 64, list_pos;
703  int nz_coeff[64];
704  int nz_coeff_count = 0;
705 
706  coef_list[list_end] = 4; mode_list[list_end++] = 0;
707  coef_list[list_end] = 24; mode_list[list_end++] = 0;
708  coef_list[list_end] = 44; mode_list[list_end++] = 0;
709  coef_list[list_end] = 0; mode_list[list_end++] = 2;
710 
711  for (mask = 1 << get_bits(gb, 3); mask; mask >>= 1) {
712  for (i = 0; i < nz_coeff_count; i++) {
713  if (!get_bits1(gb))
714  continue;
715  if (block[nz_coeff[i]] < 0)
716  block[nz_coeff[i]] -= mask;
717  else
718  block[nz_coeff[i]] += mask;
719  masks_count--;
720  if (masks_count < 0)
721  return 0;
722  }
723  list_pos = list_start;
724  while (list_pos < list_end) {
725  if (!(coef_list[list_pos] | mode_list[list_pos]) || !get_bits1(gb)) {
726  list_pos++;
727  continue;
728  }
729  ccoef = coef_list[list_pos];
730  mode = mode_list[list_pos];
731  switch (mode) {
732  case 0:
733  coef_list[list_pos] = ccoef + 4;
734  mode_list[list_pos] = 1;
735  case 2:
736  if (mode == 2) {
737  coef_list[list_pos] = 0;
738  mode_list[list_pos++] = 0;
739  }
740  for (i = 0; i < 4; i++, ccoef++) {
741  if (get_bits1(gb)) {
742  coef_list[--list_start] = ccoef;
743  mode_list[ list_start] = 3;
744  } else {
745  nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
746  sign = -get_bits1(gb);
747  block[bink_scan[ccoef]] = (mask ^ sign) - sign;
748  masks_count--;
749  if (masks_count < 0)
750  return 0;
751  }
752  }
753  break;
754  case 1:
755  mode_list[list_pos] = 2;
756  for (i = 0; i < 3; i++) {
757  ccoef += 4;
758  coef_list[list_end] = ccoef;
759  mode_list[list_end++] = 2;
760  }
761  break;
762  case 3:
763  nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
764  sign = -get_bits1(gb);
765  block[bink_scan[ccoef]] = (mask ^ sign) - sign;
766  coef_list[list_pos] = 0;
767  mode_list[list_pos++] = 0;
768  masks_count--;
769  if (masks_count < 0)
770  return 0;
771  break;
772  }
773  }
774  }
775 
776  return 0;
777 }
778 
782 static inline void put_pixels8x8_overlapped(uint8_t *dst, uint8_t *src, int stride)
783 {
784  uint8_t tmp[64];
785  int i;
786  for (i = 0; i < 8; i++)
787  memcpy(tmp + i*8, src + i*stride, 8);
788  for (i = 0; i < 8; i++)
789  memcpy(dst + i*stride, tmp + i*8, 8);
790 }
791 
792 static int binkb_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
793  int is_key, int is_chroma)
794 {
795  int blk;
796  int i, j, bx, by;
797  uint8_t *dst, *ref, *ref_start, *ref_end;
798  int v, col[2];
799  const uint8_t *scan;
800  int xoff, yoff;
802  LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
803  int coordmap[64];
804  int ybias = is_key ? -15 : 0;
805  int qp;
806 
807  const int stride = c->pic.linesize[plane_idx];
808  int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3;
809  int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
810 
812  ref_start = c->pic.data[plane_idx];
813  ref_end = c->pic.data[plane_idx] + (bh * c->pic.linesize[plane_idx] + bw) * 8;
814 
815  for (i = 0; i < 64; i++)
816  coordmap[i] = (i & 7) + (i >> 3) * stride;
817 
818  for (by = 0; by < bh; by++) {
819  for (i = 0; i < BINKB_NB_SRC; i++) {
820  if (binkb_read_bundle(c, gb, i) < 0)
821  return -1;
822  }
823 
824  dst = c->pic.data[plane_idx] + 8*by*stride;
825  for (bx = 0; bx < bw; bx++, dst += 8) {
827  switch (blk) {
828  case 0:
829  break;
830  case 1:
831  scan = bink_patterns[get_bits(gb, 4)];
832  i = 0;
833  do {
834  int mode, run;
835 
836  mode = get_bits1(gb);
837  run = get_bits(gb, binkb_runbits[i]) + 1;
838 
839  i += run;
840  if (i > 64) {
841  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
842  return -1;
843  }
844  if (mode) {
846  for (j = 0; j < run; j++)
847  dst[coordmap[*scan++]] = v;
848  } else {
849  for (j = 0; j < run; j++)
850  dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
851  }
852  } while (i < 63);
853  if (i == 63)
854  dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS);
855  break;
856  case 2:
857  memset(dctblock, 0, sizeof(*dctblock) * 64);
858  dctblock[0] = binkb_get_value(c, BINKB_SRC_INTRA_DC);
860  read_dct_coeffs(gb, dctblock, bink_scan, binkb_intra_quant, qp);
861  c->bdsp.idct_put(dst, stride, dctblock);
862  break;
863  case 3:
864  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
865  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
866  ref = dst + xoff + yoff * stride;
867  if (ref < ref_start || ref + 8*stride > ref_end) {
868  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
869  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
870  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
871  } else {
872  put_pixels8x8_overlapped(dst, ref, stride);
873  }
874  c->dsp.clear_block(block);
876  read_residue(gb, block, v);
877  c->dsp.add_pixels8(dst, block, stride);
878  break;
879  case 4:
880  xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
881  yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
882  ref = dst + xoff + yoff * stride;
883  if (ref < ref_start || ref + 8 * stride > ref_end) {
884  av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
885  } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
886  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
887  } else {
888  put_pixels8x8_overlapped(dst, ref, stride);
889  }
890  memset(dctblock, 0, sizeof(*dctblock) * 64);
891  dctblock[0] = binkb_get_value(c, BINKB_SRC_INTER_DC);
893  read_dct_coeffs(gb, dctblock, bink_scan, binkb_inter_quant, qp);
894  c->bdsp.idct_add(dst, stride, dctblock);
895  break;
896  case 5:
898  c->dsp.fill_block_tab[1](dst, v, stride, 8);
899  break;
900  case 6:
901  for (i = 0; i < 2; i++)
902  col[i] = binkb_get_value(c, BINKB_SRC_COLORS);
903  for (i = 0; i < 8; i++) {
905  for (j = 0; j < 8; j++, v >>= 1)
906  dst[i*stride + j] = col[v & 1];
907  }
908  break;
909  case 7:
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->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
917  } else {
918  put_pixels8x8_overlapped(dst, ref, stride);
919  }
920  break;
921  case 8:
922  for (i = 0; i < 8; i++)
923  memcpy(dst + i*stride, c->bundle[BINKB_SRC_COLORS].cur_ptr + i*8, 8);
924  c->bundle[BINKB_SRC_COLORS].cur_ptr += 64;
925  break;
926  default:
927  av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
928  return -1;
929  }
930  }
931  }
932  if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary
933  skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
934 
935  return 0;
936 }
937 
938 static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
939  int is_chroma)
940 {
941  int blk;
942  int i, j, bx, by;
943  uint8_t *dst, *prev, *ref, *ref_start, *ref_end;
944  int v, col[2];
945  const uint8_t *scan;
946  int xoff, yoff;
948  LOCAL_ALIGNED_16(uint8_t, ublock, [64]);
949  LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
950  int coordmap[64];
951 
952  const int stride = c->pic.linesize[plane_idx];
953  int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3;
954  int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
955  int width = c->avctx->width >> is_chroma;
956 
957  init_lengths(c, FFMAX(width, 8), bw);
958  for (i = 0; i < BINK_NB_SRC; i++)
959  read_bundle(gb, c, i);
960 
961  ref_start = c->last.data[plane_idx] ? c->last.data[plane_idx]
962  : c->pic.data[plane_idx];
963  ref_end = ref_start
964  + (bw - 1 + c->last.linesize[plane_idx] * (bh - 1)) * 8;
965 
966  for (i = 0; i < 64; i++)
967  coordmap[i] = (i & 7) + (i >> 3) * stride;
968 
969  for (by = 0; by < bh; by++) {
970  if (read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0)
971  return -1;
973  return -1;
974  if (read_colors(gb, &c->bundle[BINK_SRC_COLORS], c) < 0)
975  return -1;
976  if (read_patterns(c->avctx, gb, &c->bundle[BINK_SRC_PATTERN]) < 0)
977  return -1;
978  if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_X_OFF]) < 0)
979  return -1;
980  if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_Y_OFF]) < 0)
981  return -1;
982  if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0)
983  return -1;
984  if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0)
985  return -1;
986  if (read_runs(c->avctx, gb, &c->bundle[BINK_SRC_RUN]) < 0)
987  return -1;
988 
989  if (by == bh)
990  break;
991  dst = c->pic.data[plane_idx] + 8*by*stride;
992  prev = (c->last.data[plane_idx] ? c->last.data[plane_idx]
993  : c->pic.data[plane_idx]) + 8*by*stride;
994  for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) {
996  // 16x16 block type on odd line means part of the already decoded block, so skip it
997  if ((by & 1) && blk == SCALED_BLOCK) {
998  bx++;
999  dst += 8;
1000  prev += 8;
1001  continue;
1002  }
1003  switch (blk) {
1004  case SKIP_BLOCK:
1005  c->dsp.put_pixels_tab[1][0](dst, prev, stride, 8);
1006  break;
1007  case SCALED_BLOCK:
1009  switch (blk) {
1010  case RUN_BLOCK:
1011  scan = bink_patterns[get_bits(gb, 4)];
1012  i = 0;
1013  do {
1014  int run = get_value(c, BINK_SRC_RUN) + 1;
1015 
1016  i += run;
1017  if (i > 64) {
1018  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
1019  return -1;
1020  }
1021  if (get_bits1(gb)) {
1022  v = get_value(c, BINK_SRC_COLORS);
1023  for (j = 0; j < run; j++)
1024  ublock[*scan++] = v;
1025  } else {
1026  for (j = 0; j < run; j++)
1027  ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
1028  }
1029  } while (i < 63);
1030  if (i == 63)
1031  ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
1032  break;
1033  case INTRA_BLOCK:
1034  memset(dctblock, 0, sizeof(*dctblock) * 64);
1035  dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
1036  read_dct_coeffs(gb, dctblock, bink_scan, bink_intra_quant, -1);
1037  c->bdsp.idct_put(ublock, 8, dctblock);
1038  break;
1039  case FILL_BLOCK:
1040  v = get_value(c, BINK_SRC_COLORS);
1041  c->dsp.fill_block_tab[0](dst, v, stride, 16);
1042  break;
1043  case PATTERN_BLOCK:
1044  for (i = 0; i < 2; i++)
1045  col[i] = get_value(c, BINK_SRC_COLORS);
1046  for (j = 0; j < 8; j++) {
1047  v = get_value(c, BINK_SRC_PATTERN);
1048  for (i = 0; i < 8; i++, v >>= 1)
1049  ublock[i + j*8] = col[v & 1];
1050  }
1051  break;
1052  case RAW_BLOCK:
1053  for (j = 0; j < 8; j++)
1054  for (i = 0; i < 8; i++)
1055  ublock[i + j*8] = get_value(c, BINK_SRC_COLORS);
1056  break;
1057  default:
1058  av_log(c->avctx, AV_LOG_ERROR, "Incorrect 16x16 block type %d\n", blk);
1059  return -1;
1060  }
1061  if (blk != FILL_BLOCK)
1062  c->bdsp.scale_block(ublock, dst, stride);
1063  bx++;
1064  dst += 8;
1065  prev += 8;
1066  break;
1067  case MOTION_BLOCK:
1068  xoff = get_value(c, BINK_SRC_X_OFF);
1069  yoff = get_value(c, BINK_SRC_Y_OFF);
1070  ref = prev + xoff + yoff * stride;
1071  if (ref < ref_start || ref > ref_end) {
1072  av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
1073  bx*8 + xoff, by*8 + yoff);
1074  return -1;
1075  }
1076  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
1077  break;
1078  case RUN_BLOCK:
1079  scan = bink_patterns[get_bits(gb, 4)];
1080  i = 0;
1081  do {
1082  int run = get_value(c, BINK_SRC_RUN) + 1;
1083 
1084  i += run;
1085  if (i > 64) {
1086  av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
1087  return -1;
1088  }
1089  if (get_bits1(gb)) {
1090  v = get_value(c, BINK_SRC_COLORS);
1091  for (j = 0; j < run; j++)
1092  dst[coordmap[*scan++]] = v;
1093  } else {
1094  for (j = 0; j < run; j++)
1095  dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
1096  }
1097  } while (i < 63);
1098  if (i == 63)
1099  dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
1100  break;
1101  case RESIDUE_BLOCK:
1102  xoff = get_value(c, BINK_SRC_X_OFF);
1103  yoff = get_value(c, BINK_SRC_Y_OFF);
1104  ref = prev + xoff + yoff * stride;
1105  if (ref < ref_start || ref > ref_end) {
1106  av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
1107  bx*8 + xoff, by*8 + yoff);
1108  return -1;
1109  }
1110  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
1111  c->dsp.clear_block(block);
1112  v = get_bits(gb, 7);
1113  read_residue(gb, block, v);
1114  c->dsp.add_pixels8(dst, block, stride);
1115  break;
1116  case INTRA_BLOCK:
1117  memset(dctblock, 0, sizeof(*dctblock) * 64);
1118  dctblock[0] = get_value(c, BINK_SRC_INTRA_DC);
1119  read_dct_coeffs(gb, dctblock, bink_scan, bink_intra_quant, -1);
1120  c->bdsp.idct_put(dst, stride, dctblock);
1121  break;
1122  case FILL_BLOCK:
1123  v = get_value(c, BINK_SRC_COLORS);
1124  c->dsp.fill_block_tab[1](dst, v, stride, 8);
1125  break;
1126  case INTER_BLOCK:
1127  xoff = get_value(c, BINK_SRC_X_OFF);
1128  yoff = get_value(c, BINK_SRC_Y_OFF);
1129  ref = prev + xoff + yoff * stride;
1130  c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
1131  memset(dctblock, 0, sizeof(*dctblock) * 64);
1132  dctblock[0] = get_value(c, BINK_SRC_INTER_DC);
1133  read_dct_coeffs(gb, dctblock, bink_scan, bink_inter_quant, -1);
1134  c->bdsp.idct_add(dst, stride, dctblock);
1135  break;
1136  case PATTERN_BLOCK:
1137  for (i = 0; i < 2; i++)
1138  col[i] = get_value(c, BINK_SRC_COLORS);
1139  for (i = 0; i < 8; i++) {
1140  v = get_value(c, BINK_SRC_PATTERN);
1141  for (j = 0; j < 8; j++, v >>= 1)
1142  dst[i*stride + j] = col[v & 1];
1143  }
1144  break;
1145  case RAW_BLOCK:
1146  for (i = 0; i < 8; i++)
1147  memcpy(dst + i*stride, c->bundle[BINK_SRC_COLORS].cur_ptr + i*8, 8);
1148  c->bundle[BINK_SRC_COLORS].cur_ptr += 64;
1149  break;
1150  default:
1151  av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
1152  return -1;
1153  }
1154  }
1155  }
1156  if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary
1157  skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
1158 
1159  return 0;
1160 }
1161 
1162 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt)
1163 {
1164  BinkContext * const c = avctx->priv_data;
1165  GetBitContext gb;
1166  int plane, plane_idx;
1167  int bits_count = pkt->size << 3;
1168 
1169  if (c->version > 'b') {
1170  if(c->pic.data[0])
1171  avctx->release_buffer(avctx, &c->pic);
1172 
1173  if(avctx->get_buffer(avctx, &c->pic) < 0){
1174  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1175  return -1;
1176  }
1177  } else {
1178  if(avctx->reget_buffer(avctx, &c->pic) < 0){
1179  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1180  return -1;
1181  }
1182  }
1183 
1184  init_get_bits(&gb, pkt->data, bits_count);
1185  if (c->has_alpha) {
1186  if (c->version >= 'i')
1187  skip_bits_long(&gb, 32);
1188  if (bink_decode_plane(c, &gb, 3, 0) < 0)
1189  return -1;
1190  }
1191  if (c->version >= 'i')
1192  skip_bits_long(&gb, 32);
1193 
1194  for (plane = 0; plane < 3; plane++) {
1195  plane_idx = (!plane || !c->swap_planes) ? plane : (plane ^ 3);
1196 
1197  if (c->version > 'b') {
1198  if (bink_decode_plane(c, &gb, plane_idx, !!plane) < 0)
1199  return -1;
1200  } else {
1201  if (binkb_decode_plane(c, &gb, plane_idx, !pkt->pts, !!plane) < 0)
1202  return -1;
1203  }
1204  if (get_bits_count(&gb) >= bits_count)
1205  break;
1206  }
1207  emms_c();
1208 
1209  *data_size = sizeof(AVFrame);
1210  *(AVFrame*)data = c->pic;
1211 
1212  if (c->version > 'b')
1213  FFSWAP(AVFrame, c->pic, c->last);
1214 
1215  /* always report that the buffer was completely consumed */
1216  return pkt->size;
1217 }
1218 
1222 static av_cold void binkb_calc_quant(void)
1223 {
1224  uint8_t inv_bink_scan[64];
1225  double s[64];
1226  int i, j;
1227 
1228  for (j = 0; j < 8; j++) {
1229  for (i = 0; i < 8; i++) {
1230  if (j && j != 4)
1231  if (i && i != 4)
1232  s[j*8 + i] = cos(j * M_PI/16.0) * cos(i * M_PI/16.0) * 2.0;
1233  else
1234  s[j*8 + i] = cos(j * M_PI/16.0) * sqrt(2.0);
1235  else
1236  if (i && i != 4)
1237  s[j*8 + i] = cos(i * M_PI/16.0) * sqrt(2.0);
1238  else
1239  s[j*8 + i] = 1.0;
1240  }
1241  }
1242 
1243  for (i = 0; i < 64; i++)
1244  inv_bink_scan[bink_scan[i]] = i;
1245 
1246  for (j = 0; j < 16; j++) {
1247  for (i = 0; i < 64; i++) {
1248  int k = inv_bink_scan[i];
1249  if (s[i] == 1.0) {
1250  binkb_intra_quant[j][k] = (1L << 12) * binkb_intra_seed[i] *
1251  binkb_num[j]/binkb_den[j];
1252  binkb_inter_quant[j][k] = (1L << 12) * binkb_inter_seed[i] *
1253  binkb_num[j]/binkb_den[j];
1254  } else {
1255  binkb_intra_quant[j][k] = (1L << 12) * binkb_intra_seed[i] * s[i] *
1256  binkb_num[j]/(double)binkb_den[j];
1257  binkb_inter_quant[j][k] = (1L << 12) * binkb_inter_seed[i] * s[i] *
1258  binkb_num[j]/(double)binkb_den[j];
1259  }
1260  }
1261  }
1262 }
1263 
1265 {
1266  BinkContext * const c = avctx->priv_data;
1267  static VLC_TYPE table[16 * 128][2];
1268  static int binkb_initialised = 0;
1269  int i;
1270  int flags;
1271 
1272  c->version = avctx->codec_tag >> 24;
1273  if (avctx->extradata_size < 4) {
1274  av_log(avctx, AV_LOG_ERROR, "Extradata missing or too short\n");
1275  return -1;
1276  }
1277  flags = AV_RL32(avctx->extradata);
1278  c->has_alpha = flags & BINK_FLAG_ALPHA;
1279  c->swap_planes = c->version >= 'h';
1280  if (!bink_trees[15].table) {
1281  for (i = 0; i < 16; i++) {
1282  const int maxbits = bink_tree_lens[i][15];
1283  bink_trees[i].table = table + i*128;
1284  bink_trees[i].table_allocated = 1 << maxbits;
1285  init_vlc(&bink_trees[i], maxbits, 16,
1286  bink_tree_lens[i], 1, 1,
1288  }
1289  }
1290  c->avctx = avctx;
1291 
1292  c->pic.data[0] = NULL;
1293 
1294  if (av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0) {
1295  return 1;
1296  }
1297 
1299 
1300  avctx->idct_algo = FF_IDCT_BINK;
1301  dsputil_init(&c->dsp, avctx);
1302  ff_binkdsp_init(&c->bdsp);
1303 
1304  init_bundles(c);
1305 
1306  if (c->version == 'b') {
1307  if (!binkb_initialised) {
1308  binkb_calc_quant();
1309  binkb_initialised = 1;
1310  }
1311  }
1312 
1313  return 0;
1314 }
1315 
1317 {
1318  BinkContext * const c = avctx->priv_data;
1319 
1320  if (c->pic.data[0])
1321  avctx->release_buffer(avctx, &c->pic);
1322  if (c->last.data[0])
1323  avctx->release_buffer(avctx, &c->last);
1324 
1325  free_bundles(c);
1326  return 0;
1327 }
1328 
1330  .name = "binkvideo",
1331  .type = AVMEDIA_TYPE_VIDEO,
1332  .id = CODEC_ID_BINKVIDEO,
1333  .priv_data_size = sizeof(BinkContext),
1334  .init = decode_init,
1335  .close = decode_end,
1336  .decode = decode_frame,
1337  .long_name = NULL_IF_CONFIG_SMALL("Bink video"),
1338 };