Libav 0.7.1
|
00001 /* 00002 * Bink video decoder 00003 * Copyright (c) 2009 Konstantin Shishkov 00004 * Copyright (C) 2011 Peter Ross <pross@xvid.org> 00005 * 00006 * This file is part of Libav. 00007 * 00008 * Libav is free software; you can redistribute it and/or 00009 * modify it under the terms of the GNU Lesser General Public 00010 * License as published by the Free Software Foundation; either 00011 * version 2.1 of the License, or (at your option) any later version. 00012 * 00013 * Libav is distributed in the hope that it will be useful, 00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00016 * Lesser General Public License for more details. 00017 * 00018 * You should have received a copy of the GNU Lesser General Public 00019 * License along with Libav; if not, write to the Free Software 00020 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00021 */ 00022 00023 #include "libavutil/imgutils.h" 00024 #include "avcodec.h" 00025 #include "dsputil.h" 00026 #include "binkdata.h" 00027 #include "mathops.h" 00028 00029 #define ALT_BITSTREAM_READER_LE 00030 #include "get_bits.h" 00031 00032 #define BINK_FLAG_ALPHA 0x00100000 00033 #define BINK_FLAG_GRAY 0x00020000 00034 00035 static VLC bink_trees[16]; 00036 00040 enum OldSources { 00041 BINKB_SRC_BLOCK_TYPES = 0, 00042 BINKB_SRC_COLORS, 00043 BINKB_SRC_PATTERN, 00044 BINKB_SRC_X_OFF, 00045 BINKB_SRC_Y_OFF, 00046 BINKB_SRC_INTRA_DC, 00047 BINKB_SRC_INTER_DC, 00048 BINKB_SRC_INTRA_Q, 00049 BINKB_SRC_INTER_Q, 00050 BINKB_SRC_INTER_COEFS, 00051 00052 BINKB_NB_SRC 00053 }; 00054 00055 static const int binkb_bundle_sizes[BINKB_NB_SRC] = { 00056 4, 8, 8, 5, 5, 11, 11, 4, 4, 7 00057 }; 00058 00059 static const int binkb_bundle_signed[BINKB_NB_SRC] = { 00060 0, 0, 0, 1, 1, 0, 1, 0, 0, 0 00061 }; 00062 00063 static uint32_t binkb_intra_quant[16][64]; 00064 static uint32_t binkb_inter_quant[16][64]; 00065 00069 enum Sources { 00070 BINK_SRC_BLOCK_TYPES = 0, 00071 BINK_SRC_SUB_BLOCK_TYPES, 00072 BINK_SRC_COLORS, 00073 BINK_SRC_PATTERN, 00074 BINK_SRC_X_OFF, 00075 BINK_SRC_Y_OFF, 00076 BINK_SRC_INTRA_DC, 00077 BINK_SRC_INTER_DC, 00078 BINK_SRC_RUN, 00079 00080 BINK_NB_SRC 00081 }; 00082 00086 typedef struct Tree { 00087 int vlc_num; 00088 uint8_t syms[16]; 00089 } Tree; 00090 00091 #define GET_HUFF(gb, tree) (tree).syms[get_vlc2(gb, bink_trees[(tree).vlc_num].table,\ 00092 bink_trees[(tree).vlc_num].bits, 1)] 00093 00097 typedef struct Bundle { 00098 int len; 00099 Tree tree; 00100 uint8_t *data; 00101 uint8_t *data_end; 00102 uint8_t *cur_dec; 00103 uint8_t *cur_ptr; 00104 } Bundle; 00105 00106 /* 00107 * Decoder context 00108 */ 00109 typedef struct BinkContext { 00110 AVCodecContext *avctx; 00111 DSPContext dsp; 00112 AVFrame pic, last; 00113 int version; 00114 int has_alpha; 00115 int swap_planes; 00116 ScanTable scantable; 00117 00118 Bundle bundle[BINKB_NB_SRC]; 00119 Tree col_high[16]; 00120 int col_lastval; 00121 } BinkContext; 00122 00126 enum BlockTypes { 00127 SKIP_BLOCK = 0, 00128 SCALED_BLOCK, 00129 MOTION_BLOCK, 00130 RUN_BLOCK, 00131 RESIDUE_BLOCK, 00132 INTRA_BLOCK, 00133 FILL_BLOCK, 00134 INTER_BLOCK, 00135 PATTERN_BLOCK, 00136 RAW_BLOCK, 00137 }; 00138 00146 static void init_lengths(BinkContext *c, int width, int bw) 00147 { 00148 c->bundle[BINK_SRC_BLOCK_TYPES].len = av_log2((width >> 3) + 511) + 1; 00149 00150 c->bundle[BINK_SRC_SUB_BLOCK_TYPES].len = av_log2((width >> 4) + 511) + 1; 00151 00152 c->bundle[BINK_SRC_COLORS].len = av_log2(bw*64 + 511) + 1; 00153 00154 c->bundle[BINK_SRC_INTRA_DC].len = 00155 c->bundle[BINK_SRC_INTER_DC].len = 00156 c->bundle[BINK_SRC_X_OFF].len = 00157 c->bundle[BINK_SRC_Y_OFF].len = av_log2((width >> 3) + 511) + 1; 00158 00159 c->bundle[BINK_SRC_PATTERN].len = av_log2((bw << 3) + 511) + 1; 00160 00161 c->bundle[BINK_SRC_RUN].len = av_log2(bw*48 + 511) + 1; 00162 } 00163 00169 static av_cold void init_bundles(BinkContext *c) 00170 { 00171 int bw, bh, blocks; 00172 int i; 00173 00174 bw = (c->avctx->width + 7) >> 3; 00175 bh = (c->avctx->height + 7) >> 3; 00176 blocks = bw * bh; 00177 00178 for (i = 0; i < BINKB_NB_SRC; i++) { 00179 c->bundle[i].data = av_malloc(blocks * 64); 00180 c->bundle[i].data_end = c->bundle[i].data + blocks * 64; 00181 } 00182 } 00183 00189 static av_cold void free_bundles(BinkContext *c) 00190 { 00191 int i; 00192 for (i = 0; i < BINKB_NB_SRC; i++) 00193 av_freep(&c->bundle[i].data); 00194 } 00195 00204 static void merge(GetBitContext *gb, uint8_t *dst, uint8_t *src, int size) 00205 { 00206 uint8_t *src2 = src + size; 00207 int size2 = size; 00208 00209 do { 00210 if (!get_bits1(gb)) { 00211 *dst++ = *src++; 00212 size--; 00213 } else { 00214 *dst++ = *src2++; 00215 size2--; 00216 } 00217 } while (size && size2); 00218 00219 while (size--) 00220 *dst++ = *src++; 00221 while (size2--) 00222 *dst++ = *src2++; 00223 } 00224 00231 static void read_tree(GetBitContext *gb, Tree *tree) 00232 { 00233 uint8_t tmp1[16], tmp2[16], *in = tmp1, *out = tmp2; 00234 int i, t, len; 00235 00236 tree->vlc_num = get_bits(gb, 4); 00237 if (!tree->vlc_num) { 00238 for (i = 0; i < 16; i++) 00239 tree->syms[i] = i; 00240 return; 00241 } 00242 if (get_bits1(gb)) { 00243 len = get_bits(gb, 3); 00244 memset(tmp1, 0, sizeof(tmp1)); 00245 for (i = 0; i <= len; i++) { 00246 tree->syms[i] = get_bits(gb, 4); 00247 tmp1[tree->syms[i]] = 1; 00248 } 00249 for (i = 0; i < 16 && len < 16 - 1; i++) 00250 if (!tmp1[i]) 00251 tree->syms[++len] = i; 00252 } else { 00253 len = get_bits(gb, 2); 00254 for (i = 0; i < 16; i++) 00255 in[i] = i; 00256 for (i = 0; i <= len; i++) { 00257 int size = 1 << i; 00258 for (t = 0; t < 16; t += size << 1) 00259 merge(gb, out + t, in + t, size); 00260 FFSWAP(uint8_t*, in, out); 00261 } 00262 memcpy(tree->syms, in, 16); 00263 } 00264 } 00265 00273 static void read_bundle(GetBitContext *gb, BinkContext *c, int bundle_num) 00274 { 00275 int i; 00276 00277 if (bundle_num == BINK_SRC_COLORS) { 00278 for (i = 0; i < 16; i++) 00279 read_tree(gb, &c->col_high[i]); 00280 c->col_lastval = 0; 00281 } 00282 if (bundle_num != BINK_SRC_INTRA_DC && bundle_num != BINK_SRC_INTER_DC) 00283 read_tree(gb, &c->bundle[bundle_num].tree); 00284 c->bundle[bundle_num].cur_dec = 00285 c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data; 00286 } 00287 00295 #define CHECK_READ_VAL(gb, b, t) \ 00296 if (!b->cur_dec || (b->cur_dec > b->cur_ptr)) \ 00297 return 0; \ 00298 t = get_bits(gb, b->len); \ 00299 if (!t) { \ 00300 b->cur_dec = NULL; \ 00301 return 0; \ 00302 } \ 00303 00304 static int read_runs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b) 00305 { 00306 int t, v; 00307 const uint8_t *dec_end; 00308 00309 CHECK_READ_VAL(gb, b, t); 00310 dec_end = b->cur_dec + t; 00311 if (dec_end > b->data_end) { 00312 av_log(avctx, AV_LOG_ERROR, "Run value went out of bounds\n"); 00313 return -1; 00314 } 00315 if (get_bits1(gb)) { 00316 v = get_bits(gb, 4); 00317 memset(b->cur_dec, v, t); 00318 b->cur_dec += t; 00319 } else { 00320 while (b->cur_dec < dec_end) 00321 *b->cur_dec++ = GET_HUFF(gb, b->tree); 00322 } 00323 return 0; 00324 } 00325 00326 static int read_motion_values(AVCodecContext *avctx, GetBitContext *gb, Bundle *b) 00327 { 00328 int t, sign, v; 00329 const uint8_t *dec_end; 00330 00331 CHECK_READ_VAL(gb, b, t); 00332 dec_end = b->cur_dec + t; 00333 if (dec_end > b->data_end) { 00334 av_log(avctx, AV_LOG_ERROR, "Too many motion values\n"); 00335 return -1; 00336 } 00337 if (get_bits1(gb)) { 00338 v = get_bits(gb, 4); 00339 if (v) { 00340 sign = -get_bits1(gb); 00341 v = (v ^ sign) - sign; 00342 } 00343 memset(b->cur_dec, v, t); 00344 b->cur_dec += t; 00345 } else { 00346 while (b->cur_dec < dec_end) { 00347 v = GET_HUFF(gb, b->tree); 00348 if (v) { 00349 sign = -get_bits1(gb); 00350 v = (v ^ sign) - sign; 00351 } 00352 *b->cur_dec++ = v; 00353 } 00354 } 00355 return 0; 00356 } 00357 00358 static const uint8_t bink_rlelens[4] = { 4, 8, 12, 32 }; 00359 00360 static int read_block_types(AVCodecContext *avctx, GetBitContext *gb, Bundle *b) 00361 { 00362 int t, v; 00363 int last = 0; 00364 const uint8_t *dec_end; 00365 00366 CHECK_READ_VAL(gb, b, t); 00367 dec_end = b->cur_dec + t; 00368 if (dec_end > b->data_end) { 00369 av_log(avctx, AV_LOG_ERROR, "Too many block type values\n"); 00370 return -1; 00371 } 00372 if (get_bits1(gb)) { 00373 v = get_bits(gb, 4); 00374 memset(b->cur_dec, v, t); 00375 b->cur_dec += t; 00376 } else { 00377 while (b->cur_dec < dec_end) { 00378 v = GET_HUFF(gb, b->tree); 00379 if (v < 12) { 00380 last = v; 00381 *b->cur_dec++ = v; 00382 } else { 00383 int run = bink_rlelens[v - 12]; 00384 00385 if (dec_end - b->cur_dec < run) 00386 return -1; 00387 memset(b->cur_dec, last, run); 00388 b->cur_dec += run; 00389 } 00390 } 00391 } 00392 return 0; 00393 } 00394 00395 static int read_patterns(AVCodecContext *avctx, GetBitContext *gb, Bundle *b) 00396 { 00397 int t, v; 00398 const uint8_t *dec_end; 00399 00400 CHECK_READ_VAL(gb, b, t); 00401 dec_end = b->cur_dec + t; 00402 if (dec_end > b->data_end) { 00403 av_log(avctx, AV_LOG_ERROR, "Too many pattern values\n"); 00404 return -1; 00405 } 00406 while (b->cur_dec < dec_end) { 00407 v = GET_HUFF(gb, b->tree); 00408 v |= GET_HUFF(gb, b->tree) << 4; 00409 *b->cur_dec++ = v; 00410 } 00411 00412 return 0; 00413 } 00414 00415 static int read_colors(GetBitContext *gb, Bundle *b, BinkContext *c) 00416 { 00417 int t, sign, v; 00418 const uint8_t *dec_end; 00419 00420 CHECK_READ_VAL(gb, b, t); 00421 dec_end = b->cur_dec + t; 00422 if (dec_end > b->data_end) { 00423 av_log(c->avctx, AV_LOG_ERROR, "Too many color values\n"); 00424 return -1; 00425 } 00426 if (get_bits1(gb)) { 00427 c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]); 00428 v = GET_HUFF(gb, b->tree); 00429 v = (c->col_lastval << 4) | v; 00430 if (c->version < 'i') { 00431 sign = ((int8_t) v) >> 7; 00432 v = ((v & 0x7F) ^ sign) - sign; 00433 v += 0x80; 00434 } 00435 memset(b->cur_dec, v, t); 00436 b->cur_dec += t; 00437 } else { 00438 while (b->cur_dec < dec_end) { 00439 c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]); 00440 v = GET_HUFF(gb, b->tree); 00441 v = (c->col_lastval << 4) | v; 00442 if (c->version < 'i') { 00443 sign = ((int8_t) v) >> 7; 00444 v = ((v & 0x7F) ^ sign) - sign; 00445 v += 0x80; 00446 } 00447 *b->cur_dec++ = v; 00448 } 00449 } 00450 return 0; 00451 } 00452 00454 #define DC_START_BITS 11 00455 00456 static int read_dcs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b, 00457 int start_bits, int has_sign) 00458 { 00459 int i, j, len, len2, bsize, sign, v, v2; 00460 int16_t *dst = (int16_t*)b->cur_dec; 00461 int16_t *dst_end = (int16_t*)b->data_end; 00462 00463 CHECK_READ_VAL(gb, b, len); 00464 v = get_bits(gb, start_bits - has_sign); 00465 if (v && has_sign) { 00466 sign = -get_bits1(gb); 00467 v = (v ^ sign) - sign; 00468 } 00469 if (dst_end - dst < 1) 00470 return -1; 00471 *dst++ = v; 00472 len--; 00473 for (i = 0; i < len; i += 8) { 00474 len2 = FFMIN(len - i, 8); 00475 if (dst_end - dst < len2) 00476 return -1; 00477 bsize = get_bits(gb, 4); 00478 if (bsize) { 00479 for (j = 0; j < len2; j++) { 00480 v2 = get_bits(gb, bsize); 00481 if (v2) { 00482 sign = -get_bits1(gb); 00483 v2 = (v2 ^ sign) - sign; 00484 } 00485 v += v2; 00486 *dst++ = v; 00487 if (v < -32768 || v > 32767) { 00488 av_log(avctx, AV_LOG_ERROR, "DC value went out of bounds: %d\n", v); 00489 return -1; 00490 } 00491 } 00492 } else { 00493 for (j = 0; j < len2; j++) 00494 *dst++ = v; 00495 } 00496 } 00497 00498 b->cur_dec = (uint8_t*)dst; 00499 return 0; 00500 } 00501 00508 static inline int get_value(BinkContext *c, int bundle) 00509 { 00510 int ret; 00511 00512 if (bundle < BINK_SRC_X_OFF || bundle == BINK_SRC_RUN) 00513 return *c->bundle[bundle].cur_ptr++; 00514 if (bundle == BINK_SRC_X_OFF || bundle == BINK_SRC_Y_OFF) 00515 return (int8_t)*c->bundle[bundle].cur_ptr++; 00516 ret = *(int16_t*)c->bundle[bundle].cur_ptr; 00517 c->bundle[bundle].cur_ptr += 2; 00518 return ret; 00519 } 00520 00521 static void binkb_init_bundle(BinkContext *c, int bundle_num) 00522 { 00523 c->bundle[bundle_num].cur_dec = 00524 c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data; 00525 c->bundle[bundle_num].len = 13; 00526 } 00527 00528 static void binkb_init_bundles(BinkContext *c) 00529 { 00530 int i; 00531 for (i = 0; i < BINKB_NB_SRC; i++) 00532 binkb_init_bundle(c, i); 00533 } 00534 00535 static int binkb_read_bundle(BinkContext *c, GetBitContext *gb, int bundle_num) 00536 { 00537 const int bits = binkb_bundle_sizes[bundle_num]; 00538 const int mask = 1 << (bits - 1); 00539 const int issigned = binkb_bundle_signed[bundle_num]; 00540 Bundle *b = &c->bundle[bundle_num]; 00541 int i, len; 00542 00543 CHECK_READ_VAL(gb, b, len); 00544 if (b->data_end - b->cur_dec < len * (1 + (bits > 8))) 00545 return -1; 00546 if (bits <= 8) { 00547 if (!issigned) { 00548 for (i = 0; i < len; i++) 00549 *b->cur_dec++ = get_bits(gb, bits); 00550 } else { 00551 for (i = 0; i < len; i++) 00552 *b->cur_dec++ = get_bits(gb, bits) - mask; 00553 } 00554 } else { 00555 int16_t *dst = (int16_t*)b->cur_dec; 00556 00557 if (!issigned) { 00558 for (i = 0; i < len; i++) 00559 *dst++ = get_bits(gb, bits); 00560 } else { 00561 for (i = 0; i < len; i++) 00562 *dst++ = get_bits(gb, bits) - mask; 00563 } 00564 b->cur_dec = (uint8_t*)dst; 00565 } 00566 return 0; 00567 } 00568 00569 static inline int binkb_get_value(BinkContext *c, int bundle_num) 00570 { 00571 int16_t ret; 00572 const int bits = binkb_bundle_sizes[bundle_num]; 00573 00574 if (bits <= 8) { 00575 int val = *c->bundle[bundle_num].cur_ptr++; 00576 return binkb_bundle_signed[bundle_num] ? (int8_t)val : val; 00577 } 00578 ret = *(int16_t*)c->bundle[bundle_num].cur_ptr; 00579 c->bundle[bundle_num].cur_ptr += 2; 00580 return ret; 00581 } 00582 00592 static int read_dct_coeffs(GetBitContext *gb, DCTELEM block[64], const uint8_t *scan, 00593 const uint32_t quant_matrices[16][64], int q) 00594 { 00595 int coef_list[128]; 00596 int mode_list[128]; 00597 int i, t, mask, bits, ccoef, mode, sign; 00598 int list_start = 64, list_end = 64, list_pos; 00599 int coef_count = 0; 00600 int coef_idx[64]; 00601 int quant_idx; 00602 const uint32_t *quant; 00603 00604 coef_list[list_end] = 4; mode_list[list_end++] = 0; 00605 coef_list[list_end] = 24; mode_list[list_end++] = 0; 00606 coef_list[list_end] = 44; mode_list[list_end++] = 0; 00607 coef_list[list_end] = 1; mode_list[list_end++] = 3; 00608 coef_list[list_end] = 2; mode_list[list_end++] = 3; 00609 coef_list[list_end] = 3; mode_list[list_end++] = 3; 00610 00611 bits = get_bits(gb, 4) - 1; 00612 for (mask = 1 << bits; bits >= 0; mask >>= 1, bits--) { 00613 list_pos = list_start; 00614 while (list_pos < list_end) { 00615 if (!(mode_list[list_pos] | coef_list[list_pos]) || !get_bits1(gb)) { 00616 list_pos++; 00617 continue; 00618 } 00619 ccoef = coef_list[list_pos]; 00620 mode = mode_list[list_pos]; 00621 switch (mode) { 00622 case 0: 00623 coef_list[list_pos] = ccoef + 4; 00624 mode_list[list_pos] = 1; 00625 case 2: 00626 if (mode == 2) { 00627 coef_list[list_pos] = 0; 00628 mode_list[list_pos++] = 0; 00629 } 00630 for (i = 0; i < 4; i++, ccoef++) { 00631 if (get_bits1(gb)) { 00632 coef_list[--list_start] = ccoef; 00633 mode_list[ list_start] = 3; 00634 } else { 00635 int t; 00636 if (!bits) { 00637 t = 1 - (get_bits1(gb) << 1); 00638 } else { 00639 t = get_bits(gb, bits) | mask; 00640 sign = -get_bits1(gb); 00641 t = (t ^ sign) - sign; 00642 } 00643 block[scan[ccoef]] = t; 00644 coef_idx[coef_count++] = ccoef; 00645 } 00646 } 00647 break; 00648 case 1: 00649 mode_list[list_pos] = 2; 00650 for (i = 0; i < 3; i++) { 00651 ccoef += 4; 00652 coef_list[list_end] = ccoef; 00653 mode_list[list_end++] = 2; 00654 } 00655 break; 00656 case 3: 00657 if (!bits) { 00658 t = 1 - (get_bits1(gb) << 1); 00659 } else { 00660 t = get_bits(gb, bits) | mask; 00661 sign = -get_bits1(gb); 00662 t = (t ^ sign) - sign; 00663 } 00664 block[scan[ccoef]] = t; 00665 coef_idx[coef_count++] = ccoef; 00666 coef_list[list_pos] = 0; 00667 mode_list[list_pos++] = 0; 00668 break; 00669 } 00670 } 00671 } 00672 00673 if (q == -1) { 00674 quant_idx = get_bits(gb, 4); 00675 } else { 00676 quant_idx = q; 00677 } 00678 00679 quant = quant_matrices[quant_idx]; 00680 00681 block[0] = (block[0] * quant[0]) >> 11; 00682 for (i = 0; i < coef_count; i++) { 00683 int idx = coef_idx[i]; 00684 block[scan[idx]] = (block[scan[idx]] * quant[idx]) >> 11; 00685 } 00686 00687 return 0; 00688 } 00689 00698 static int read_residue(GetBitContext *gb, DCTELEM block[64], int masks_count) 00699 { 00700 int coef_list[128]; 00701 int mode_list[128]; 00702 int i, sign, mask, ccoef, mode; 00703 int list_start = 64, list_end = 64, list_pos; 00704 int nz_coeff[64]; 00705 int nz_coeff_count = 0; 00706 00707 coef_list[list_end] = 4; mode_list[list_end++] = 0; 00708 coef_list[list_end] = 24; mode_list[list_end++] = 0; 00709 coef_list[list_end] = 44; mode_list[list_end++] = 0; 00710 coef_list[list_end] = 0; mode_list[list_end++] = 2; 00711 00712 for (mask = 1 << get_bits(gb, 3); mask; mask >>= 1) { 00713 for (i = 0; i < nz_coeff_count; i++) { 00714 if (!get_bits1(gb)) 00715 continue; 00716 if (block[nz_coeff[i]] < 0) 00717 block[nz_coeff[i]] -= mask; 00718 else 00719 block[nz_coeff[i]] += mask; 00720 masks_count--; 00721 if (masks_count < 0) 00722 return 0; 00723 } 00724 list_pos = list_start; 00725 while (list_pos < list_end) { 00726 if (!(coef_list[list_pos] | mode_list[list_pos]) || !get_bits1(gb)) { 00727 list_pos++; 00728 continue; 00729 } 00730 ccoef = coef_list[list_pos]; 00731 mode = mode_list[list_pos]; 00732 switch (mode) { 00733 case 0: 00734 coef_list[list_pos] = ccoef + 4; 00735 mode_list[list_pos] = 1; 00736 case 2: 00737 if (mode == 2) { 00738 coef_list[list_pos] = 0; 00739 mode_list[list_pos++] = 0; 00740 } 00741 for (i = 0; i < 4; i++, ccoef++) { 00742 if (get_bits1(gb)) { 00743 coef_list[--list_start] = ccoef; 00744 mode_list[ list_start] = 3; 00745 } else { 00746 nz_coeff[nz_coeff_count++] = bink_scan[ccoef]; 00747 sign = -get_bits1(gb); 00748 block[bink_scan[ccoef]] = (mask ^ sign) - sign; 00749 masks_count--; 00750 if (masks_count < 0) 00751 return 0; 00752 } 00753 } 00754 break; 00755 case 1: 00756 mode_list[list_pos] = 2; 00757 for (i = 0; i < 3; i++) { 00758 ccoef += 4; 00759 coef_list[list_end] = ccoef; 00760 mode_list[list_end++] = 2; 00761 } 00762 break; 00763 case 3: 00764 nz_coeff[nz_coeff_count++] = bink_scan[ccoef]; 00765 sign = -get_bits1(gb); 00766 block[bink_scan[ccoef]] = (mask ^ sign) - sign; 00767 coef_list[list_pos] = 0; 00768 mode_list[list_pos++] = 0; 00769 masks_count--; 00770 if (masks_count < 0) 00771 return 0; 00772 break; 00773 } 00774 } 00775 } 00776 00777 return 0; 00778 } 00779 00783 static inline void put_pixels8x8_overlapped(uint8_t *dst, uint8_t *src, int stride) 00784 { 00785 uint8_t tmp[64]; 00786 int i; 00787 for (i = 0; i < 8; i++) 00788 memcpy(tmp + i*8, src + i*stride, 8); 00789 for (i = 0; i < 8; i++) 00790 memcpy(dst + i*stride, tmp + i*8, 8); 00791 } 00792 00793 static int binkb_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx, 00794 int is_key, int is_chroma) 00795 { 00796 int blk; 00797 int i, j, bx, by; 00798 uint8_t *dst, *ref, *ref_start, *ref_end; 00799 int v, col[2]; 00800 const uint8_t *scan; 00801 int xoff, yoff; 00802 LOCAL_ALIGNED_16(DCTELEM, block, [64]); 00803 int coordmap[64]; 00804 int ybias = is_key ? -15 : 0; 00805 int qp; 00806 00807 const int stride = c->pic.linesize[plane_idx]; 00808 int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3; 00809 int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3; 00810 00811 binkb_init_bundles(c); 00812 ref_start = c->pic.data[plane_idx]; 00813 ref_end = c->pic.data[plane_idx] + (bh * c->pic.linesize[plane_idx] + bw) * 8; 00814 00815 for (i = 0; i < 64; i++) 00816 coordmap[i] = (i & 7) + (i >> 3) * stride; 00817 00818 for (by = 0; by < bh; by++) { 00819 for (i = 0; i < BINKB_NB_SRC; i++) { 00820 if (binkb_read_bundle(c, gb, i) < 0) 00821 return -1; 00822 } 00823 00824 dst = c->pic.data[plane_idx] + 8*by*stride; 00825 for (bx = 0; bx < bw; bx++, dst += 8) { 00826 blk = binkb_get_value(c, BINKB_SRC_BLOCK_TYPES); 00827 switch (blk) { 00828 case 0: 00829 break; 00830 case 1: 00831 scan = bink_patterns[get_bits(gb, 4)]; 00832 i = 0; 00833 do { 00834 int mode, run; 00835 00836 mode = get_bits1(gb); 00837 run = get_bits(gb, binkb_runbits[i]) + 1; 00838 00839 i += run; 00840 if (i > 64) { 00841 av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n"); 00842 return -1; 00843 } 00844 if (mode) { 00845 v = binkb_get_value(c, BINKB_SRC_COLORS); 00846 for (j = 0; j < run; j++) 00847 dst[coordmap[*scan++]] = v; 00848 } else { 00849 for (j = 0; j < run; j++) 00850 dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS); 00851 } 00852 } while (i < 63); 00853 if (i == 63) 00854 dst[coordmap[*scan++]] = binkb_get_value(c, BINKB_SRC_COLORS); 00855 break; 00856 case 2: 00857 c->dsp.clear_block(block); 00858 block[0] = binkb_get_value(c, BINKB_SRC_INTRA_DC); 00859 qp = binkb_get_value(c, BINKB_SRC_INTRA_Q); 00860 read_dct_coeffs(gb, block, c->scantable.permutated, binkb_intra_quant, qp); 00861 c->dsp.idct_put(dst, stride, block); 00862 break; 00863 case 3: 00864 xoff = binkb_get_value(c, BINKB_SRC_X_OFF); 00865 yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias; 00866 ref = dst + xoff + yoff * stride; 00867 if (ref < ref_start || ref + 8*stride > ref_end) { 00868 av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n"); 00869 } else if (ref + 8*stride < dst || ref >= dst + 8*stride) { 00870 c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8); 00871 } else { 00872 put_pixels8x8_overlapped(dst, ref, stride); 00873 } 00874 c->dsp.clear_block(block); 00875 v = binkb_get_value(c, BINKB_SRC_INTER_COEFS); 00876 read_residue(gb, block, v); 00877 c->dsp.add_pixels8(dst, block, stride); 00878 break; 00879 case 4: 00880 xoff = binkb_get_value(c, BINKB_SRC_X_OFF); 00881 yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias; 00882 ref = dst + xoff + yoff * stride; 00883 if (ref < ref_start || ref + 8 * stride > ref_end) { 00884 av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n"); 00885 } else if (ref + 8*stride < dst || ref >= dst + 8*stride) { 00886 c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8); 00887 } else { 00888 put_pixels8x8_overlapped(dst, ref, stride); 00889 } 00890 c->dsp.clear_block(block); 00891 block[0] = binkb_get_value(c, BINKB_SRC_INTER_DC); 00892 qp = binkb_get_value(c, BINKB_SRC_INTER_Q); 00893 read_dct_coeffs(gb, block, c->scantable.permutated, binkb_inter_quant, qp); 00894 c->dsp.idct_add(dst, stride, block); 00895 break; 00896 case 5: 00897 v = binkb_get_value(c, BINKB_SRC_COLORS); 00898 c->dsp.fill_block_tab[1](dst, v, stride, 8); 00899 break; 00900 case 6: 00901 for (i = 0; i < 2; i++) 00902 col[i] = binkb_get_value(c, BINKB_SRC_COLORS); 00903 for (i = 0; i < 8; i++) { 00904 v = binkb_get_value(c, BINKB_SRC_PATTERN); 00905 for (j = 0; j < 8; j++, v >>= 1) 00906 dst[i*stride + j] = col[v & 1]; 00907 } 00908 break; 00909 case 7: 00910 xoff = binkb_get_value(c, BINKB_SRC_X_OFF); 00911 yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias; 00912 ref = dst + xoff + yoff * stride; 00913 if (ref < ref_start || ref + 8 * stride > ref_end) { 00914 av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n"); 00915 } else if (ref + 8*stride < dst || ref >= dst + 8*stride) { 00916 c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8); 00917 } else { 00918 put_pixels8x8_overlapped(dst, ref, stride); 00919 } 00920 break; 00921 case 8: 00922 for (i = 0; i < 8; i++) 00923 memcpy(dst + i*stride, c->bundle[BINKB_SRC_COLORS].cur_ptr + i*8, 8); 00924 c->bundle[BINKB_SRC_COLORS].cur_ptr += 64; 00925 break; 00926 default: 00927 av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk); 00928 return -1; 00929 } 00930 } 00931 } 00932 if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary 00933 skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F)); 00934 00935 return 0; 00936 } 00937 00938 static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx, 00939 int is_chroma) 00940 { 00941 int blk; 00942 int i, j, bx, by; 00943 uint8_t *dst, *prev, *ref, *ref_start, *ref_end; 00944 int v, col[2]; 00945 const uint8_t *scan; 00946 int xoff, yoff; 00947 LOCAL_ALIGNED_16(DCTELEM, block, [64]); 00948 LOCAL_ALIGNED_16(uint8_t, ublock, [64]); 00949 int coordmap[64]; 00950 00951 const int stride = c->pic.linesize[plane_idx]; 00952 int bw = is_chroma ? (c->avctx->width + 15) >> 4 : (c->avctx->width + 7) >> 3; 00953 int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3; 00954 int width = c->avctx->width >> is_chroma; 00955 00956 init_lengths(c, FFMAX(width, 8), bw); 00957 for (i = 0; i < BINK_NB_SRC; i++) 00958 read_bundle(gb, c, i); 00959 00960 ref_start = c->last.data[plane_idx] ? c->last.data[plane_idx] 00961 : c->pic.data[plane_idx]; 00962 ref_end = ref_start 00963 + (bw - 1 + c->last.linesize[plane_idx] * (bh - 1)) * 8; 00964 00965 for (i = 0; i < 64; i++) 00966 coordmap[i] = (i & 7) + (i >> 3) * stride; 00967 00968 for (by = 0; by < bh; by++) { 00969 if (read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0) 00970 return -1; 00971 if (read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_SUB_BLOCK_TYPES]) < 0) 00972 return -1; 00973 if (read_colors(gb, &c->bundle[BINK_SRC_COLORS], c) < 0) 00974 return -1; 00975 if (read_patterns(c->avctx, gb, &c->bundle[BINK_SRC_PATTERN]) < 0) 00976 return -1; 00977 if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_X_OFF]) < 0) 00978 return -1; 00979 if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_Y_OFF]) < 0) 00980 return -1; 00981 if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0) 00982 return -1; 00983 if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0) 00984 return -1; 00985 if (read_runs(c->avctx, gb, &c->bundle[BINK_SRC_RUN]) < 0) 00986 return -1; 00987 00988 if (by == bh) 00989 break; 00990 dst = c->pic.data[plane_idx] + 8*by*stride; 00991 prev = (c->last.data[plane_idx] ? c->last.data[plane_idx] 00992 : c->pic.data[plane_idx]) + 8*by*stride; 00993 for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) { 00994 blk = get_value(c, BINK_SRC_BLOCK_TYPES); 00995 // 16x16 block type on odd line means part of the already decoded block, so skip it 00996 if ((by & 1) && blk == SCALED_BLOCK) { 00997 bx++; 00998 dst += 8; 00999 prev += 8; 01000 continue; 01001 } 01002 switch (blk) { 01003 case SKIP_BLOCK: 01004 c->dsp.put_pixels_tab[1][0](dst, prev, stride, 8); 01005 break; 01006 case SCALED_BLOCK: 01007 blk = get_value(c, BINK_SRC_SUB_BLOCK_TYPES); 01008 switch (blk) { 01009 case RUN_BLOCK: 01010 scan = bink_patterns[get_bits(gb, 4)]; 01011 i = 0; 01012 do { 01013 int run = get_value(c, BINK_SRC_RUN) + 1; 01014 01015 i += run; 01016 if (i > 64) { 01017 av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n"); 01018 return -1; 01019 } 01020 if (get_bits1(gb)) { 01021 v = get_value(c, BINK_SRC_COLORS); 01022 for (j = 0; j < run; j++) 01023 ublock[*scan++] = v; 01024 } else { 01025 for (j = 0; j < run; j++) 01026 ublock[*scan++] = get_value(c, BINK_SRC_COLORS); 01027 } 01028 } while (i < 63); 01029 if (i == 63) 01030 ublock[*scan++] = get_value(c, BINK_SRC_COLORS); 01031 break; 01032 case INTRA_BLOCK: 01033 c->dsp.clear_block(block); 01034 block[0] = get_value(c, BINK_SRC_INTRA_DC); 01035 read_dct_coeffs(gb, block, c->scantable.permutated, bink_intra_quant, -1); 01036 c->dsp.idct(block); 01037 c->dsp.put_pixels_nonclamped(block, ublock, 8); 01038 break; 01039 case FILL_BLOCK: 01040 v = get_value(c, BINK_SRC_COLORS); 01041 c->dsp.fill_block_tab[0](dst, v, stride, 16); 01042 break; 01043 case PATTERN_BLOCK: 01044 for (i = 0; i < 2; i++) 01045 col[i] = get_value(c, BINK_SRC_COLORS); 01046 for (j = 0; j < 8; j++) { 01047 v = get_value(c, BINK_SRC_PATTERN); 01048 for (i = 0; i < 8; i++, v >>= 1) 01049 ublock[i + j*8] = col[v & 1]; 01050 } 01051 break; 01052 case RAW_BLOCK: 01053 for (j = 0; j < 8; j++) 01054 for (i = 0; i < 8; i++) 01055 ublock[i + j*8] = get_value(c, BINK_SRC_COLORS); 01056 break; 01057 default: 01058 av_log(c->avctx, AV_LOG_ERROR, "Incorrect 16x16 block type %d\n", blk); 01059 return -1; 01060 } 01061 if (blk != FILL_BLOCK) 01062 c->dsp.scale_block(ublock, dst, stride); 01063 bx++; 01064 dst += 8; 01065 prev += 8; 01066 break; 01067 case MOTION_BLOCK: 01068 xoff = get_value(c, BINK_SRC_X_OFF); 01069 yoff = get_value(c, BINK_SRC_Y_OFF); 01070 ref = prev + xoff + yoff * stride; 01071 if (ref < ref_start || ref > ref_end) { 01072 av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n", 01073 bx*8 + xoff, by*8 + yoff); 01074 return -1; 01075 } 01076 c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8); 01077 break; 01078 case RUN_BLOCK: 01079 scan = bink_patterns[get_bits(gb, 4)]; 01080 i = 0; 01081 do { 01082 int run = get_value(c, BINK_SRC_RUN) + 1; 01083 01084 i += run; 01085 if (i > 64) { 01086 av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n"); 01087 return -1; 01088 } 01089 if (get_bits1(gb)) { 01090 v = get_value(c, BINK_SRC_COLORS); 01091 for (j = 0; j < run; j++) 01092 dst[coordmap[*scan++]] = v; 01093 } else { 01094 for (j = 0; j < run; j++) 01095 dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS); 01096 } 01097 } while (i < 63); 01098 if (i == 63) 01099 dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS); 01100 break; 01101 case RESIDUE_BLOCK: 01102 xoff = get_value(c, BINK_SRC_X_OFF); 01103 yoff = get_value(c, BINK_SRC_Y_OFF); 01104 ref = prev + xoff + yoff * stride; 01105 if (ref < ref_start || ref > ref_end) { 01106 av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n", 01107 bx*8 + xoff, by*8 + yoff); 01108 return -1; 01109 } 01110 c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8); 01111 c->dsp.clear_block(block); 01112 v = get_bits(gb, 7); 01113 read_residue(gb, block, v); 01114 c->dsp.add_pixels8(dst, block, stride); 01115 break; 01116 case INTRA_BLOCK: 01117 c->dsp.clear_block(block); 01118 block[0] = get_value(c, BINK_SRC_INTRA_DC); 01119 read_dct_coeffs(gb, block, c->scantable.permutated, bink_intra_quant, -1); 01120 c->dsp.idct_put(dst, stride, block); 01121 break; 01122 case FILL_BLOCK: 01123 v = get_value(c, BINK_SRC_COLORS); 01124 c->dsp.fill_block_tab[1](dst, v, stride, 8); 01125 break; 01126 case INTER_BLOCK: 01127 xoff = get_value(c, BINK_SRC_X_OFF); 01128 yoff = get_value(c, BINK_SRC_Y_OFF); 01129 ref = prev + xoff + yoff * stride; 01130 c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8); 01131 c->dsp.clear_block(block); 01132 block[0] = get_value(c, BINK_SRC_INTER_DC); 01133 read_dct_coeffs(gb, block, c->scantable.permutated, bink_inter_quant, -1); 01134 c->dsp.idct_add(dst, stride, block); 01135 break; 01136 case PATTERN_BLOCK: 01137 for (i = 0; i < 2; i++) 01138 col[i] = get_value(c, BINK_SRC_COLORS); 01139 for (i = 0; i < 8; i++) { 01140 v = get_value(c, BINK_SRC_PATTERN); 01141 for (j = 0; j < 8; j++, v >>= 1) 01142 dst[i*stride + j] = col[v & 1]; 01143 } 01144 break; 01145 case RAW_BLOCK: 01146 for (i = 0; i < 8; i++) 01147 memcpy(dst + i*stride, c->bundle[BINK_SRC_COLORS].cur_ptr + i*8, 8); 01148 c->bundle[BINK_SRC_COLORS].cur_ptr += 64; 01149 break; 01150 default: 01151 av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk); 01152 return -1; 01153 } 01154 } 01155 } 01156 if (get_bits_count(gb) & 0x1F) //next plane data starts at 32-bit boundary 01157 skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F)); 01158 01159 return 0; 01160 } 01161 01162 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt) 01163 { 01164 BinkContext * const c = avctx->priv_data; 01165 GetBitContext gb; 01166 int plane, plane_idx; 01167 int bits_count = pkt->size << 3; 01168 01169 if (c->version > 'b') { 01170 if(c->pic.data[0]) 01171 avctx->release_buffer(avctx, &c->pic); 01172 01173 if(avctx->get_buffer(avctx, &c->pic) < 0){ 01174 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 01175 return -1; 01176 } 01177 } else { 01178 if(avctx->reget_buffer(avctx, &c->pic) < 0){ 01179 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); 01180 return -1; 01181 } 01182 } 01183 01184 init_get_bits(&gb, pkt->data, bits_count); 01185 if (c->has_alpha) { 01186 if (c->version >= 'i') 01187 skip_bits_long(&gb, 32); 01188 if (bink_decode_plane(c, &gb, 3, 0) < 0) 01189 return -1; 01190 } 01191 if (c->version >= 'i') 01192 skip_bits_long(&gb, 32); 01193 01194 for (plane = 0; plane < 3; plane++) { 01195 plane_idx = (!plane || !c->swap_planes) ? plane : (plane ^ 3); 01196 01197 if (c->version > 'b') { 01198 if (bink_decode_plane(c, &gb, plane_idx, !!plane) < 0) 01199 return -1; 01200 } else { 01201 if (binkb_decode_plane(c, &gb, plane_idx, !pkt->pts, !!plane) < 0) 01202 return -1; 01203 } 01204 if (get_bits_count(&gb) >= bits_count) 01205 break; 01206 } 01207 emms_c(); 01208 01209 *data_size = sizeof(AVFrame); 01210 *(AVFrame*)data = c->pic; 01211 01212 if (c->version > 'b') 01213 FFSWAP(AVFrame, c->pic, c->last); 01214 01215 /* always report that the buffer was completely consumed */ 01216 return pkt->size; 01217 } 01218 01222 static av_cold void binkb_calc_quant(void) 01223 { 01224 uint8_t inv_bink_scan[64]; 01225 double s[64]; 01226 int i, j; 01227 01228 for (j = 0; j < 8; j++) { 01229 for (i = 0; i < 8; i++) { 01230 if (j && j != 4) 01231 if (i && i != 4) 01232 s[j*8 + i] = cos(j * M_PI/16.0) * cos(i * M_PI/16.0) * 2.0; 01233 else 01234 s[j*8 + i] = cos(j * M_PI/16.0) * sqrt(2.0); 01235 else 01236 if (i && i != 4) 01237 s[j*8 + i] = cos(i * M_PI/16.0) * sqrt(2.0); 01238 else 01239 s[j*8 + i] = 1.0; 01240 } 01241 } 01242 01243 for (i = 0; i < 64; i++) 01244 inv_bink_scan[bink_scan[i]] = i; 01245 01246 for (j = 0; j < 16; j++) { 01247 for (i = 0; i < 64; i++) { 01248 int k = inv_bink_scan[i]; 01249 if (s[i] == 1.0) { 01250 binkb_intra_quant[j][k] = (1L << 12) * binkb_intra_seed[i] * 01251 binkb_num[j]/binkb_den[j]; 01252 binkb_inter_quant[j][k] = (1L << 12) * binkb_inter_seed[i] * 01253 binkb_num[j]/binkb_den[j]; 01254 } else { 01255 binkb_intra_quant[j][k] = (1L << 12) * binkb_intra_seed[i] * s[i] * 01256 binkb_num[j]/(double)binkb_den[j]; 01257 binkb_inter_quant[j][k] = (1L << 12) * binkb_inter_seed[i] * s[i] * 01258 binkb_num[j]/(double)binkb_den[j]; 01259 } 01260 } 01261 } 01262 } 01263 01264 static av_cold int decode_init(AVCodecContext *avctx) 01265 { 01266 BinkContext * const c = avctx->priv_data; 01267 static VLC_TYPE table[16 * 128][2]; 01268 static int binkb_initialised = 0; 01269 int i; 01270 int flags; 01271 01272 c->version = avctx->codec_tag >> 24; 01273 if (avctx->extradata_size < 4) { 01274 av_log(avctx, AV_LOG_ERROR, "Extradata missing or too short\n"); 01275 return -1; 01276 } 01277 flags = AV_RL32(avctx->extradata); 01278 c->has_alpha = flags & BINK_FLAG_ALPHA; 01279 c->swap_planes = c->version >= 'h'; 01280 if (!bink_trees[15].table) { 01281 for (i = 0; i < 16; i++) { 01282 const int maxbits = bink_tree_lens[i][15]; 01283 bink_trees[i].table = table + i*128; 01284 bink_trees[i].table_allocated = 1 << maxbits; 01285 init_vlc(&bink_trees[i], maxbits, 16, 01286 bink_tree_lens[i], 1, 1, 01287 bink_tree_bits[i], 1, 1, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE); 01288 } 01289 } 01290 c->avctx = avctx; 01291 01292 c->pic.data[0] = NULL; 01293 01294 if (av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0) { 01295 return 1; 01296 } 01297 01298 avctx->pix_fmt = c->has_alpha ? PIX_FMT_YUVA420P : PIX_FMT_YUV420P; 01299 01300 avctx->idct_algo = FF_IDCT_BINK; 01301 dsputil_init(&c->dsp, avctx); 01302 ff_init_scantable(c->dsp.idct_permutation, &c->scantable, bink_scan); 01303 01304 init_bundles(c); 01305 01306 if (c->version == 'b') { 01307 if (!binkb_initialised) { 01308 binkb_calc_quant(); 01309 binkb_initialised = 1; 01310 } 01311 } 01312 01313 return 0; 01314 } 01315 01316 static av_cold int decode_end(AVCodecContext *avctx) 01317 { 01318 BinkContext * const c = avctx->priv_data; 01319 01320 if (c->pic.data[0]) 01321 avctx->release_buffer(avctx, &c->pic); 01322 if (c->last.data[0]) 01323 avctx->release_buffer(avctx, &c->last); 01324 01325 free_bundles(c); 01326 return 0; 01327 } 01328 01329 AVCodec ff_bink_decoder = { 01330 "binkvideo", 01331 AVMEDIA_TYPE_VIDEO, 01332 CODEC_ID_BINKVIDEO, 01333 sizeof(BinkContext), 01334 decode_init, 01335 NULL, 01336 decode_end, 01337 decode_frame, 01338 .long_name = NULL_IF_CONFIG_SMALL("Bink video"), 01339 };