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