Mercurial > libavcodec.hg
annotate bink.c @ 11251:56e65f21e9c5 libavcodec
Bink video decoder now can use extradata to detect alpha plane presence
author | kostya |
---|---|
date | Tue, 23 Feb 2010 06:39:23 +0000 |
parents | b48dd9213016 |
children | d6513f6a949e |
rev | line source |
---|---|
11231 | 1 /* |
2 * Bink video decoder | |
3 * Copyright (c) 2009 Konstantin Shishkov | |
4 * | |
5 * This file is part of FFmpeg. | |
6 * | |
7 * FFmpeg is free software; you can redistribute it and/or | |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2.1 of the License, or (at your option) any later version. | |
11 * | |
12 * FFmpeg is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
18 * License along with FFmpeg; if not, write to the Free Software | |
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 */ | |
21 | |
22 #include "avcodec.h" | |
23 #include "dsputil.h" | |
24 #include "binkdata.h" | |
25 #include "mathops.h" | |
26 | |
27 #define ALT_BITSTREAM_READER_LE | |
28 #include "get_bits.h" | |
29 | |
11251
56e65f21e9c5
Bink video decoder now can use extradata to detect alpha plane presence
kostya
parents:
11247
diff
changeset
|
30 #define BINK_FLAG_ALPHA 0x00100000 |
56e65f21e9c5
Bink video decoder now can use extradata to detect alpha plane presence
kostya
parents:
11247
diff
changeset
|
31 #define BINK_FLAG_GRAY 0x00020000 |
56e65f21e9c5
Bink video decoder now can use extradata to detect alpha plane presence
kostya
parents:
11247
diff
changeset
|
32 |
11231 | 33 static VLC bink_trees[16]; |
34 | |
35 /** | |
36 * IDs for different data types used in Bink video codec | |
37 */ | |
38 enum Sources { | |
39 BINK_SRC_BLOCK_TYPES = 0, ///< 8x8 block types | |
40 BINK_SRC_SUB_BLOCK_TYPES, ///< 16x16 block types (a subset of 8x8 block types) | |
41 BINK_SRC_COLORS, ///< pixel values used for different block types | |
42 BINK_SRC_PATTERN, ///< 8-bit values for 2-colour pattern fill | |
43 BINK_SRC_X_OFF, ///< X components of motion value | |
44 BINK_SRC_Y_OFF, ///< Y components of motion value | |
45 BINK_SRC_INTRA_DC, ///< DC values for intrablocks with DCT | |
46 BINK_SRC_INTER_DC, ///< DC values for intrablocks with DCT | |
47 BINK_SRC_RUN, ///< run lengths for special fill block | |
48 | |
49 BINK_NB_SRC | |
50 }; | |
51 | |
52 /** | |
53 * data needed to decode 4-bit Huffman-coded value | |
54 */ | |
55 typedef struct Tree { | |
56 int vlc_num; ///< tree number (in bink_trees[]) | |
57 uint8_t syms[16]; ///< leaf value to symbol mapping | |
58 } Tree; | |
59 | |
60 #define GET_HUFF(gb, tree) (tree).syms[get_vlc2(gb, bink_trees[(tree).vlc_num].table,\ | |
61 bink_trees[(tree).vlc_num].bits, 1)] | |
62 | |
63 /** | |
64 * data structure used for decoding single Bink data type | |
65 */ | |
66 typedef struct Bundle { | |
67 int len; ///< length of number of entries to decode (in bits) | |
68 Tree tree; ///< Huffman tree-related data | |
69 uint8_t *data; ///< buffer for decoded symbols | |
70 uint8_t *data_end; ///< buffer end | |
71 uint8_t *cur_dec; ///< pointer to the not yet decoded part of the buffer | |
72 uint8_t *cur_ptr; ///< pointer to the data that is not read from buffer yet | |
73 } Bundle; | |
74 | |
75 /* | |
76 * Decoder context | |
77 */ | |
78 typedef struct BinkContext { | |
79 AVCodecContext *avctx; | |
80 DSPContext dsp; | |
81 AVFrame pic, last; | |
82 int version; ///< internal Bink file version | |
11247 | 83 int has_alpha; |
11231 | 84 int swap_planes; |
85 ScanTable scantable; ///< permutated scantable for DCT coeffs decoding | |
86 | |
87 Bundle bundle[BINK_NB_SRC]; ///< bundles for decoding all data types | |
88 Tree col_high[16]; ///< trees for decoding high nibble in "colours" data type | |
89 int col_lastval; ///< value of last decoded high nibble in "colours" data type | |
90 } BinkContext; | |
91 | |
92 /** | |
93 * Bink video block types | |
94 */ | |
95 enum BlockTypes { | |
96 SKIP_BLOCK = 0, ///< skipped block | |
97 SCALED_BLOCK, ///< block has size 16x16 | |
98 MOTION_BLOCK, ///< block is copied from previous frame with some offset | |
99 RUN_BLOCK, ///< block is composed from runs of colours with custom scan order | |
100 RESIDUE_BLOCK, ///< motion block with some difference added | |
101 INTRA_BLOCK, ///< intra DCT block | |
102 FILL_BLOCK, ///< block is filled with single colour | |
103 INTER_BLOCK, ///< motion block with DCT applied to the difference | |
104 PATTERN_BLOCK, ///< block is filled with two colours following custom pattern | |
105 RAW_BLOCK, ///< uncoded 8x8 block | |
106 }; | |
107 | |
108 /** | |
109 * Initializes length length in all bundles. | |
110 * | |
111 * @param c decoder context | |
112 * @param width plane width | |
113 * @param bw plane width in 8x8 blocks | |
114 */ | |
115 static void init_lengths(BinkContext *c, int width, int bw) | |
116 { | |
117 c->bundle[BINK_SRC_BLOCK_TYPES].len = av_log2((width >> 3) + 511) + 1; | |
118 | |
119 c->bundle[BINK_SRC_SUB_BLOCK_TYPES].len = av_log2((width >> 4) + 511) + 1; | |
120 | |
121 c->bundle[BINK_SRC_COLORS].len = av_log2((width >> 3)*64 + 511) + 1; | |
122 | |
123 c->bundle[BINK_SRC_INTRA_DC].len = | |
124 c->bundle[BINK_SRC_INTER_DC].len = | |
125 c->bundle[BINK_SRC_X_OFF].len = | |
126 c->bundle[BINK_SRC_Y_OFF].len = av_log2((width >> 3) + 511) + 1; | |
127 | |
128 c->bundle[BINK_SRC_PATTERN].len = av_log2((bw << 3) + 511) + 1; | |
129 | |
130 c->bundle[BINK_SRC_RUN].len = av_log2((width >> 3)*48 + 511) + 1; | |
131 } | |
132 | |
133 /** | |
134 * Allocates memory for bundles. | |
135 * | |
136 * @param c decoder context | |
137 */ | |
138 static av_cold void init_bundles(BinkContext *c) | |
139 { | |
140 int bw, bh, blocks; | |
141 int i; | |
142 | |
143 bw = (c->avctx->width + 7) >> 3; | |
144 bh = (c->avctx->height + 7) >> 3; | |
145 blocks = bw * bh; | |
146 | |
147 for (i = 0; i < BINK_NB_SRC; i++) { | |
148 c->bundle[i].data = av_malloc(blocks * 64); | |
149 c->bundle[i].data_end = c->bundle[i].data + blocks * 64; | |
150 } | |
151 } | |
152 | |
153 /** | |
154 * Frees memory used by bundles. | |
155 * | |
156 * @param c decoder context | |
157 */ | |
158 static av_cold void free_bundles(BinkContext *c) | |
159 { | |
160 int i; | |
161 for (i = 0; i < BINK_NB_SRC; i++) | |
162 av_freep(&c->bundle[i].data); | |
163 } | |
164 | |
165 /** | |
166 * Merges two consequent lists of equal size depending on bits read. | |
167 * | |
168 * @param gb context for reading bits | |
169 * @param dst buffer where merged list will be written to | |
170 * @param src pointer to the head of the first list (the second lists starts at src+size) | |
171 * @param size input lists size | |
172 */ | |
173 static void merge(GetBitContext *gb, uint8_t *dst, uint8_t *src, int size) | |
174 { | |
175 uint8_t *src2 = src + size; | |
176 int size2 = size; | |
177 | |
178 do { | |
179 if (!get_bits1(gb)) { | |
180 *dst++ = *src++; | |
181 size--; | |
182 } else { | |
183 *dst++ = *src2++; | |
184 size2--; | |
185 } | |
186 } while (size && size2); | |
187 | |
188 while (size--) | |
189 *dst++ = *src++; | |
190 while (size2--) | |
191 *dst++ = *src2++; | |
192 } | |
193 | |
194 /** | |
195 * Reads information about Huffman tree used to decode data. | |
196 * | |
197 * @param gb context for reading bits | |
198 * @param tree pointer for storing tree data | |
199 */ | |
200 static void read_tree(GetBitContext *gb, Tree *tree) | |
201 { | |
202 uint8_t tmp1[16], tmp2[16], *in = tmp1, *out = tmp2; | |
203 int i, t, len; | |
204 | |
205 tree->vlc_num = get_bits(gb, 4); | |
206 if (!tree->vlc_num) { | |
207 for (i = 0; i < 16; i++) | |
208 tree->syms[i] = i; | |
209 return; | |
210 } | |
211 if (get_bits1(gb)) { | |
212 len = get_bits(gb, 3); | |
213 memset(tmp1, 0, sizeof(tmp1)); | |
214 for (i = 0; i <= len; i++) { | |
215 tree->syms[i] = get_bits(gb, 4); | |
216 tmp1[tree->syms[i]] = 1; | |
217 } | |
218 for (i = 0; i < 16; i++) | |
219 if (!tmp1[i]) | |
220 tree->syms[++len] = i; | |
221 } else { | |
222 len = get_bits(gb, 2); | |
223 for (i = 0; i < 16; i++) | |
224 in[i] = i; | |
225 for (i = 0; i <= len; i++) { | |
226 int size = 1 << i; | |
227 for (t = 0; t < 16; t += size << 1) | |
228 merge(gb, out + t, in + t, size); | |
229 FFSWAP(uint8_t*, in, out); | |
230 } | |
231 memcpy(tree->syms, in, 16); | |
232 } | |
233 } | |
234 | |
235 /** | |
236 * Prepares bundle for decoding data. | |
237 * | |
238 * @param gb context for reading bits | |
239 * @param c decoder context | |
240 * @param bundle_num number of the bundle to initialize | |
241 */ | |
242 static void read_bundle(GetBitContext *gb, BinkContext *c, int bundle_num) | |
243 { | |
244 int i; | |
245 | |
246 if (bundle_num == BINK_SRC_COLORS) { | |
247 for (i = 0; i < 16; i++) | |
248 read_tree(gb, &c->col_high[i]); | |
249 c->col_lastval = 0; | |
250 } | |
251 if (bundle_num != BINK_SRC_INTRA_DC && bundle_num != BINK_SRC_INTER_DC) | |
252 read_tree(gb, &c->bundle[bundle_num].tree); | |
253 c->bundle[bundle_num].cur_dec = | |
254 c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data; | |
255 } | |
256 | |
257 /** | |
258 * common check before starting decoding bundle data | |
259 * | |
260 * @param gb context for reading bits | |
261 * @param b bundle | |
262 * @param t variable where number of elements to decode will be stored | |
263 */ | |
264 #define CHECK_READ_VAL(gb, b, t) \ | |
265 if (!b->cur_dec || (b->cur_dec > b->cur_ptr)) \ | |
266 return 0; \ | |
267 t = get_bits(gb, b->len); \ | |
268 if (!t) { \ | |
269 b->cur_dec = NULL; \ | |
270 return 0; \ | |
271 } \ | |
272 | |
273 static int read_runs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b) | |
274 { | |
275 int t, v; | |
276 const uint8_t *dec_end; | |
277 | |
278 CHECK_READ_VAL(gb, b, t); | |
279 dec_end = b->cur_dec + t; | |
280 if (dec_end > b->data_end) { | |
281 av_log(avctx, AV_LOG_ERROR, "Run value went out of bounds\n"); | |
282 return -1; | |
283 } | |
284 if (get_bits1(gb)) { | |
285 v = get_bits(gb, 4); | |
286 memset(b->cur_dec, v, t); | |
287 b->cur_dec += t; | |
288 } else { | |
289 while (b->cur_dec < dec_end) | |
290 *b->cur_dec++ = GET_HUFF(gb, b->tree); | |
291 } | |
292 return 0; | |
293 } | |
294 | |
295 static int read_motion_values(AVCodecContext *avctx, GetBitContext *gb, Bundle *b) | |
296 { | |
297 int t, sign, v; | |
298 const uint8_t *dec_end; | |
299 | |
300 CHECK_READ_VAL(gb, b, t); | |
301 dec_end = b->cur_dec + t; | |
302 if (dec_end > b->data_end) { | |
303 av_log(avctx, AV_LOG_ERROR, "Too many motion values\n"); | |
304 return -1; | |
305 } | |
306 if (get_bits1(gb)) { | |
307 v = get_bits(gb, 4); | |
308 if (v) { | |
309 sign = -get_bits1(gb); | |
310 v = (v ^ sign) - sign; | |
311 } | |
312 memset(b->cur_dec, v, t); | |
313 b->cur_dec += t; | |
314 } else { | |
315 do { | |
316 v = GET_HUFF(gb, b->tree); | |
317 if (v) { | |
318 sign = -get_bits1(gb); | |
319 v = (v ^ sign) - sign; | |
320 } | |
321 *b->cur_dec++ = v; | |
322 } while (b->cur_dec < dec_end); | |
323 } | |
324 return 0; | |
325 } | |
326 | |
327 const uint8_t bink_rlelens[4] = { 4, 8, 12, 32 }; | |
328 | |
329 static int read_block_types(AVCodecContext *avctx, GetBitContext *gb, Bundle *b) | |
330 { | |
331 int t, v; | |
332 int last = 0; | |
333 const uint8_t *dec_end; | |
334 | |
335 CHECK_READ_VAL(gb, b, t); | |
336 dec_end = b->cur_dec + t; | |
337 if (dec_end > b->data_end) { | |
338 av_log(avctx, AV_LOG_ERROR, "Too many block type values\n"); | |
339 return -1; | |
340 } | |
341 if (get_bits1(gb)) { | |
342 v = get_bits(gb, 4); | |
343 memset(b->cur_dec, v, t); | |
344 b->cur_dec += t; | |
345 } else { | |
346 do { | |
347 v = GET_HUFF(gb, b->tree); | |
348 if (v < 12) { | |
349 last = v; | |
350 *b->cur_dec++ = v; | |
351 } else { | |
352 int run = bink_rlelens[v - 12]; | |
353 | |
354 memset(b->cur_dec, last, run); | |
355 b->cur_dec += run; | |
356 } | |
357 } while (b->cur_dec < dec_end); | |
358 } | |
359 return 0; | |
360 } | |
361 | |
362 static int read_patterns(AVCodecContext *avctx, GetBitContext *gb, Bundle *b) | |
363 { | |
364 int t, v; | |
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 pattern values\n"); | |
371 return -1; | |
372 } | |
373 while (b->cur_dec < dec_end) { | |
374 v = GET_HUFF(gb, b->tree); | |
375 v |= GET_HUFF(gb, b->tree) << 4; | |
376 *b->cur_dec++ = v; | |
377 } | |
378 | |
379 return 0; | |
380 } | |
381 | |
382 static int read_colors(GetBitContext *gb, Bundle *b, BinkContext *c) | |
383 { | |
384 int t, sign, v; | |
385 const uint8_t *dec_end; | |
386 | |
387 CHECK_READ_VAL(gb, b, t); | |
388 dec_end = b->cur_dec + t; | |
389 if (dec_end > b->data_end) { | |
390 av_log(c->avctx, AV_LOG_ERROR, "Too many color values\n"); | |
391 return -1; | |
392 } | |
393 if (get_bits1(gb)) { | |
394 c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]); | |
395 v = GET_HUFF(gb, b->tree); | |
396 v = (c->col_lastval << 4) | v; | |
397 if (c->version < 'i') { | |
398 sign = ((int8_t) v) >> 7; | |
399 v = ((v & 0x7F) ^ sign) - sign; | |
400 v += 0x80; | |
401 } | |
402 memset(b->cur_dec, v, t); | |
403 b->cur_dec += t; | |
404 } else { | |
405 while (b->cur_dec < dec_end) { | |
406 c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]); | |
407 v = GET_HUFF(gb, b->tree); | |
408 v = (c->col_lastval << 4) | v; | |
409 if (c->version < 'i') { | |
410 sign = ((int8_t) v) >> 7; | |
411 v = ((v & 0x7F) ^ sign) - sign; | |
412 v += 0x80; | |
413 } | |
414 *b->cur_dec++ = v; | |
415 } | |
416 } | |
417 return 0; | |
418 } | |
419 | |
420 /** number of bits used to store first DC value in bundle */ | |
421 #define DC_START_BITS 11 | |
422 | |
423 static int read_dcs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b, | |
424 int start_bits, int has_sign) | |
425 { | |
426 int i, j, len, len2, bsize, sign, v, v2; | |
427 int16_t *dst = (int16_t*)b->cur_dec; | |
428 | |
429 CHECK_READ_VAL(gb, b, len); | |
430 v = get_bits(gb, start_bits - has_sign); | |
431 if (v && has_sign) { | |
432 sign = -get_bits1(gb); | |
433 v = (v ^ sign) - sign; | |
434 } | |
435 *dst++ = v; | |
436 len--; | |
437 for (i = 0; i < len; i += 8) { | |
438 len2 = FFMIN(len - i, 8); | |
439 bsize = get_bits(gb, 4); | |
440 if (bsize) { | |
441 for (j = 0; j < len2; j++) { | |
442 v2 = get_bits(gb, bsize); | |
443 if (v2) { | |
444 sign = -get_bits1(gb); | |
445 v2 = (v2 ^ sign) - sign; | |
446 } | |
447 v += v2; | |
448 *dst++ = v; | |
449 if (v < -32768 || v > 32767) { | |
450 av_log(avctx, AV_LOG_ERROR, "DC value went out of bounds: %d\n", v); | |
451 return -1; | |
452 } | |
453 } | |
454 } else { | |
455 for (j = 0; j < len2; j++) | |
456 *dst++ = v; | |
457 } | |
458 } | |
459 | |
460 b->cur_dec = (uint8_t*)dst; | |
461 return 0; | |
462 } | |
463 | |
464 /** | |
465 * Retrieves next value from bundle. | |
466 * | |
467 * @param c decoder context | |
468 * @param bundle bundle number | |
469 */ | |
470 static inline int get_value(BinkContext *c, int bundle) | |
471 { | |
472 int16_t ret; | |
473 | |
474 if (bundle < BINK_SRC_X_OFF || bundle == BINK_SRC_RUN) | |
475 return *c->bundle[bundle].cur_ptr++; | |
476 if (bundle == BINK_SRC_X_OFF || bundle == BINK_SRC_Y_OFF) | |
477 return (int8_t)*c->bundle[bundle].cur_ptr++; | |
478 ret = *(int16_t*)c->bundle[bundle].cur_ptr; | |
479 c->bundle[bundle].cur_ptr += 2; | |
480 return ret; | |
481 } | |
482 | |
483 /** | |
484 * Reads 8x8 block of DCT coefficients. | |
485 * | |
486 * @param gb context for reading bits | |
487 * @param block place for storing coefficients | |
488 * @param scan scan order table | |
489 * @param is_intra tells what set of quantizer matrices to use | |
490 * @return 0 for success, negative value in other cases | |
491 */ | |
492 static int read_dct_coeffs(GetBitContext *gb, DCTELEM block[64], const uint8_t *scan, | |
493 int is_intra) | |
494 { | |
495 int coef_list[128]; | |
496 int mode_list[128]; | |
497 int i, t, mask, bits, ccoef, mode, sign; | |
498 int list_start = 64, list_end = 64, list_pos; | |
499 int coef_count = 0; | |
500 int coef_idx[64]; | |
501 int quant_idx; | |
502 const uint32_t *quant; | |
503 | |
504 coef_list[list_end] = 4; mode_list[list_end++] = 0; | |
505 coef_list[list_end] = 24; mode_list[list_end++] = 0; | |
506 coef_list[list_end] = 44; mode_list[list_end++] = 0; | |
507 coef_list[list_end] = 1; mode_list[list_end++] = 3; | |
508 coef_list[list_end] = 2; mode_list[list_end++] = 3; | |
509 coef_list[list_end] = 3; mode_list[list_end++] = 3; | |
510 | |
511 bits = get_bits(gb, 4) - 1; | |
512 for (mask = 1 << bits; bits >= 0; mask >>= 1, bits--) { | |
513 list_pos = list_start; | |
514 while (list_pos < list_end) { | |
515 if (!(mode_list[list_pos] | coef_list[list_pos]) || !get_bits1(gb)) { | |
516 list_pos++; | |
517 continue; | |
518 } | |
519 ccoef = coef_list[list_pos]; | |
520 mode = mode_list[list_pos]; | |
521 switch (mode) { | |
522 case 0: | |
523 coef_list[list_pos] = ccoef + 4; | |
524 mode_list[list_pos] = 1; | |
525 case 2: | |
526 if (mode == 2) { | |
527 coef_list[list_pos] = 0; | |
528 mode_list[list_pos++] = 0; | |
529 } | |
530 for (i = 0; i < 4; i++, ccoef++) { | |
531 if (get_bits1(gb)) { | |
532 coef_list[--list_start] = ccoef; | |
533 mode_list[ list_start] = 3; | |
534 } else { | |
535 int t; | |
536 if (!bits) { | |
537 t = 1 - (get_bits1(gb) << 1); | |
538 } else { | |
539 t = get_bits(gb, bits) | mask; | |
540 sign = -get_bits1(gb); | |
541 t = (t ^ sign) - sign; | |
542 } | |
543 block[scan[ccoef]] = t; | |
544 coef_idx[coef_count++] = ccoef; | |
545 } | |
546 } | |
547 break; | |
548 case 1: | |
549 mode_list[list_pos] = 2; | |
550 for (i = 0; i < 3; i++) { | |
551 ccoef += 4; | |
552 coef_list[list_end] = ccoef; | |
553 mode_list[list_end++] = 2; | |
554 } | |
555 break; | |
556 case 3: | |
557 if (!bits) { | |
558 t = 1 - (get_bits1(gb) << 1); | |
559 } else { | |
560 t = get_bits(gb, bits) | mask; | |
561 sign = -get_bits1(gb); | |
562 t = (t ^ sign) - sign; | |
563 } | |
564 block[scan[ccoef]] = t; | |
565 coef_idx[coef_count++] = ccoef; | |
566 coef_list[list_pos] = 0; | |
567 mode_list[list_pos++] = 0; | |
568 break; | |
569 } | |
570 } | |
571 } | |
572 | |
573 quant_idx = get_bits(gb, 4); | |
574 quant = is_intra ? bink_intra_quant[quant_idx] | |
575 : bink_inter_quant[quant_idx]; | |
576 block[0] = (block[0] * quant[0]) >> 11; | |
577 for (i = 0; i < coef_count; i++) { | |
578 int idx = coef_idx[i]; | |
579 block[scan[idx]] = (block[scan[idx]] * quant[idx]) >> 11; | |
580 } | |
581 | |
582 return 0; | |
583 } | |
584 | |
585 /** | |
586 * Reads 8x8 block with residue after motion compensation. | |
587 * | |
588 * @param gb context for reading bits | |
589 * @param block place to store read data | |
590 * @param masks_count number of masks to decode | |
591 * @return 0 on success, negative value in other cases | |
592 */ | |
593 static int read_residue(GetBitContext *gb, DCTELEM block[64], int masks_count) | |
594 { | |
595 int coef_list[128]; | |
596 int mode_list[128]; | |
597 int i, sign, mask, ccoef, mode; | |
598 int list_start = 64, list_end = 64, list_pos; | |
599 int nz_coeff[64]; | |
600 int nz_coeff_count = 0; | |
601 | |
602 coef_list[list_end] = 4; mode_list[list_end++] = 0; | |
603 coef_list[list_end] = 24; mode_list[list_end++] = 0; | |
604 coef_list[list_end] = 44; mode_list[list_end++] = 0; | |
605 coef_list[list_end] = 0; mode_list[list_end++] = 2; | |
606 | |
607 for (mask = 1 << get_bits(gb, 3); mask; mask >>= 1) { | |
608 for (i = 0; i < nz_coeff_count; i++) { | |
609 if (!get_bits1(gb)) | |
610 continue; | |
611 if (block[nz_coeff[i]] < 0) | |
612 block[nz_coeff[i]] -= mask; | |
613 else | |
614 block[nz_coeff[i]] += mask; | |
615 masks_count--; | |
616 if (masks_count < 0) | |
617 return 0; | |
618 } | |
619 list_pos = list_start; | |
620 while (list_pos < list_end) { | |
621 if (!(coef_list[list_pos] | mode_list[list_pos]) || !get_bits1(gb)) { | |
622 list_pos++; | |
623 continue; | |
624 } | |
625 ccoef = coef_list[list_pos]; | |
626 mode = mode_list[list_pos]; | |
627 switch (mode) { | |
628 case 0: | |
629 coef_list[list_pos] = ccoef + 4; | |
630 mode_list[list_pos] = 1; | |
631 case 2: | |
632 if (mode == 2) { | |
633 coef_list[list_pos] = 0; | |
634 mode_list[list_pos++] = 0; | |
635 } | |
636 for (i = 0; i < 4; i++, ccoef++) { | |
637 if (get_bits1(gb)) { | |
638 coef_list[--list_start] = ccoef; | |
639 mode_list[ list_start] = 3; | |
640 } else { | |
641 nz_coeff[nz_coeff_count++] = bink_scan[ccoef]; | |
642 sign = -get_bits1(gb); | |
643 block[bink_scan[ccoef]] = (mask ^ sign) - sign; | |
644 masks_count--; | |
645 if (masks_count < 0) | |
646 return 0; | |
647 } | |
648 } | |
649 break; | |
650 case 1: | |
651 mode_list[list_pos] = 2; | |
652 for (i = 0; i < 3; i++) { | |
653 ccoef += 4; | |
654 coef_list[list_end] = ccoef; | |
655 mode_list[list_end++] = 2; | |
656 } | |
657 break; | |
658 case 3: | |
659 nz_coeff[nz_coeff_count++] = bink_scan[ccoef]; | |
660 sign = -get_bits1(gb); | |
661 block[bink_scan[ccoef]] = (mask ^ sign) - sign; | |
662 coef_list[list_pos] = 0; | |
663 mode_list[list_pos++] = 0; | |
664 masks_count--; | |
665 if (masks_count < 0) | |
666 return 0; | |
667 break; | |
668 } | |
669 } | |
670 } | |
671 | |
672 return 0; | |
673 } | |
674 | |
675 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt) | |
676 { | |
677 BinkContext * const c = avctx->priv_data; | |
678 GetBitContext gb; | |
679 int blk; | |
680 int i, j, plane, plane_idx, bx, by; | |
681 uint8_t *dst, *prev, *ref, *ref_start, *ref_end; | |
682 int v, col[2]; | |
683 const uint8_t *scan; | |
684 int xoff, yoff; | |
685 DECLARE_ALIGNED_16(DCTELEM, block[64]); | |
686 DECLARE_ALIGNED_16(uint8_t, ublock[64]); | |
687 int coordmap[64]; | |
11245
1e9ff636c3db
Make Bink decoder to stop decoding planes after all bits are used.
kostya
parents:
11244
diff
changeset
|
688 int bits_count = pkt->size << 3; |
11231 | 689 |
690 if(c->pic.data[0]) | |
691 avctx->release_buffer(avctx, &c->pic); | |
692 | |
693 if(avctx->get_buffer(avctx, &c->pic) < 0){ | |
694 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
695 return -1; | |
696 } | |
697 | |
11245
1e9ff636c3db
Make Bink decoder to stop decoding planes after all bits are used.
kostya
parents:
11244
diff
changeset
|
698 init_get_bits(&gb, pkt->data, bits_count); |
11247 | 699 if (c->has_alpha) { |
700 int aplane_bits = get_bits_long(&gb, 32) << 3; | |
701 if (aplane_bits <= 32 || (aplane_bits & 0x1F)) { | |
702 av_log(avctx, AV_LOG_ERROR, "Incorrect alpha plane size %d\n", aplane_bits); | |
703 return -1; | |
704 } | |
705 skip_bits_long(&gb, aplane_bits - 32); | |
706 } | |
11231 | 707 if (c->version >= 'i') |
708 skip_bits_long(&gb, 32); | |
709 | |
710 for (plane = 0; plane < 3; plane++) { | |
711 const int stride = c->pic.linesize[plane]; | |
712 int bw = plane ? (avctx->width + 15) >> 4 : (avctx->width + 7) >> 3; | |
713 int bh = plane ? (avctx->height + 15) >> 4 : (avctx->height + 7) >> 3; | |
11244
eb773ca000d9
Correct bundle lengths calculation for small Bink files.
kostya
parents:
11231
diff
changeset
|
714 int width = avctx->width >> !!plane; |
11231 | 715 |
11244
eb773ca000d9
Correct bundle lengths calculation for small Bink files.
kostya
parents:
11231
diff
changeset
|
716 init_lengths(c, FFMAX(width, 8), bw); |
11231 | 717 for (i = 0; i < BINK_NB_SRC; i++) |
718 read_bundle(&gb, c, i); | |
719 | |
720 plane_idx = (!plane || !c->swap_planes) ? plane : (plane ^ 3); | |
721 ref_start = c->last.data[plane_idx]; | |
722 ref_end = c->last.data[plane_idx] | |
723 + (bw - 1 + c->last.linesize[plane_idx] * (bh - 1)) * 8; | |
724 | |
725 for (i = 0; i < 64; i++) | |
726 coordmap[i] = (i & 7) + (i >> 3) * stride; | |
727 | |
728 for (by = 0; by < bh; by++) { | |
729 if (read_block_types(avctx, &gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0) | |
730 return -1; | |
731 if (read_block_types(avctx, &gb, &c->bundle[BINK_SRC_SUB_BLOCK_TYPES]) < 0) | |
732 return -1; | |
733 if (read_colors(&gb, &c->bundle[BINK_SRC_COLORS], c) < 0) | |
734 return -1; | |
735 if (read_patterns(avctx, &gb, &c->bundle[BINK_SRC_PATTERN]) < 0) | |
736 return -1; | |
737 if (read_motion_values(avctx, &gb, &c->bundle[BINK_SRC_X_OFF]) < 0) | |
738 return -1; | |
739 if (read_motion_values(avctx, &gb, &c->bundle[BINK_SRC_Y_OFF]) < 0) | |
740 return -1; | |
741 if (read_dcs(avctx, &gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0) | |
742 return -1; | |
743 if (read_dcs(avctx, &gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0) | |
744 return -1; | |
745 if (read_runs(avctx, &gb, &c->bundle[BINK_SRC_RUN]) < 0) | |
746 return -1; | |
747 | |
748 if (by == bh) | |
749 break; | |
750 dst = c->pic.data[plane_idx] + 8*by*stride; | |
751 prev = c->last.data[plane_idx] + 8*by*stride; | |
752 for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) { | |
753 blk = get_value(c, BINK_SRC_BLOCK_TYPES); | |
754 // 16x16 block type on odd line means part of the already decoded block, so skip it | |
755 if ((by & 1) && blk == SCALED_BLOCK) { | |
756 bx++; | |
757 dst += 8; | |
758 prev += 8; | |
759 continue; | |
760 } | |
761 switch (blk) { | |
762 case SKIP_BLOCK: | |
763 c->dsp.put_pixels_tab[1][0](dst, prev, stride, 8); | |
764 break; | |
765 case SCALED_BLOCK: | |
766 blk = get_value(c, BINK_SRC_SUB_BLOCK_TYPES); | |
767 switch (blk) { | |
768 case RUN_BLOCK: | |
769 scan = bink_patterns[get_bits(&gb, 4)]; | |
770 i = 0; | |
771 do { | |
772 int run = get_value(c, BINK_SRC_RUN) + 1; | |
773 | |
774 i += run; | |
775 if (i > 64) { | |
776 av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n"); | |
777 return -1; | |
778 } | |
779 if (get_bits1(&gb)) { | |
780 v = get_value(c, BINK_SRC_COLORS); | |
781 for (j = 0; j < run; j++) | |
782 ublock[*scan++] = v; | |
783 } else { | |
784 for (j = 0; j < run; j++) | |
785 ublock[*scan++] = get_value(c, BINK_SRC_COLORS); | |
786 } | |
787 } while (i < 63); | |
788 if (i == 63) | |
789 ublock[*scan++] = get_value(c, BINK_SRC_COLORS); | |
790 break; | |
791 case INTRA_BLOCK: | |
792 c->dsp.clear_block(block); | |
793 block[0] = get_value(c, BINK_SRC_INTRA_DC); | |
794 read_dct_coeffs(&gb, block, c->scantable.permutated, 1); | |
795 c->dsp.idct(block); | |
796 c->dsp.put_pixels_nonclamped(block, ublock, 8); | |
797 break; | |
798 case FILL_BLOCK: | |
799 v = get_value(c, BINK_SRC_COLORS); | |
800 c->dsp.fill_block_tab[0](dst, v, stride, 16); | |
801 break; | |
802 case PATTERN_BLOCK: | |
803 for (i = 0; i < 2; i++) | |
804 col[i] = get_value(c, BINK_SRC_COLORS); | |
805 for (j = 0; j < 8; j++) { | |
806 v = get_value(c, BINK_SRC_PATTERN); | |
807 for (i = 0; i < 8; i++, v >>= 1) | |
808 ublock[i + j*8] = col[v & 1]; | |
809 } | |
810 break; | |
811 case RAW_BLOCK: | |
812 for (j = 0; j < 8; j++) | |
813 for (i = 0; i < 8; i++) | |
814 ublock[i + j*8] = get_value(c, BINK_SRC_COLORS); | |
815 break; | |
816 default: | |
817 av_log(avctx, AV_LOG_ERROR, "Incorrect 16x16 block type %d\n", blk); | |
818 return -1; | |
819 } | |
820 if (blk != FILL_BLOCK) | |
821 c->dsp.scale_block(ublock, dst, stride); | |
822 bx++; | |
823 dst += 8; | |
824 prev += 8; | |
825 break; | |
826 case MOTION_BLOCK: | |
827 xoff = get_value(c, BINK_SRC_X_OFF); | |
828 yoff = get_value(c, BINK_SRC_Y_OFF); | |
829 ref = prev + xoff + yoff * stride; | |
830 if (ref < ref_start || ref > ref_end) { | |
831 av_log(avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n", | |
832 bx*8 + xoff, by*8 + yoff); | |
833 return -1; | |
834 } | |
835 c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8); | |
836 break; | |
837 case RUN_BLOCK: | |
838 scan = bink_patterns[get_bits(&gb, 4)]; | |
839 i = 0; | |
840 do { | |
841 int run = get_value(c, BINK_SRC_RUN) + 1; | |
842 | |
843 i += run; | |
844 if (i > 64) { | |
845 av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n"); | |
846 return -1; | |
847 } | |
848 if (get_bits1(&gb)) { | |
849 v = get_value(c, BINK_SRC_COLORS); | |
850 for (j = 0; j < run; j++) | |
851 dst[coordmap[*scan++]] = v; | |
852 } else { | |
853 for (j = 0; j < run; j++) | |
854 dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS); | |
855 } | |
856 } while (i < 63); | |
857 if (i == 63) | |
858 dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS); | |
859 break; | |
860 case RESIDUE_BLOCK: | |
861 xoff = get_value(c, BINK_SRC_X_OFF); | |
862 yoff = get_value(c, BINK_SRC_Y_OFF); | |
863 ref = prev + xoff + yoff * stride; | |
864 if (ref < ref_start || ref > ref_end) { | |
865 av_log(avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n", | |
866 bx*8 + xoff, by*8 + yoff); | |
867 return -1; | |
868 } | |
869 c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8); | |
870 c->dsp.clear_block(block); | |
871 v = get_bits(&gb, 7); | |
872 read_residue(&gb, block, v); | |
873 c->dsp.add_pixels8(dst, block, stride); | |
874 break; | |
875 case INTRA_BLOCK: | |
876 c->dsp.clear_block(block); | |
877 block[0] = get_value(c, BINK_SRC_INTRA_DC); | |
878 read_dct_coeffs(&gb, block, c->scantable.permutated, 1); | |
879 c->dsp.idct_put(dst, stride, block); | |
880 break; | |
881 case FILL_BLOCK: | |
882 v = get_value(c, BINK_SRC_COLORS); | |
883 c->dsp.fill_block_tab[1](dst, v, stride, 8); | |
884 break; | |
885 case INTER_BLOCK: | |
886 xoff = get_value(c, BINK_SRC_X_OFF); | |
887 yoff = get_value(c, BINK_SRC_Y_OFF); | |
888 ref = prev + xoff + yoff * stride; | |
889 c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8); | |
890 c->dsp.clear_block(block); | |
891 block[0] = get_value(c, BINK_SRC_INTER_DC); | |
892 read_dct_coeffs(&gb, block, c->scantable.permutated, 0); | |
893 c->dsp.idct_add(dst, stride, block); | |
894 break; | |
895 case PATTERN_BLOCK: | |
896 for (i = 0; i < 2; i++) | |
897 col[i] = get_value(c, BINK_SRC_COLORS); | |
898 for (i = 0; i < 8; i++) { | |
899 v = get_value(c, BINK_SRC_PATTERN); | |
900 for (j = 0; j < 8; j++, v >>= 1) | |
901 dst[i*stride + j] = col[v & 1]; | |
902 } | |
903 break; | |
904 case RAW_BLOCK: | |
905 for (i = 0; i < 8; i++) | |
906 memcpy(dst + i*stride, c->bundle[BINK_SRC_COLORS].cur_ptr + i*8, 8); | |
907 c->bundle[BINK_SRC_COLORS].cur_ptr += 64; | |
908 break; | |
909 default: | |
910 av_log(avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk); | |
911 return -1; | |
912 } | |
913 } | |
914 } | |
915 if (get_bits_count(&gb) & 0x1F) //next plane data starts at 32-bit boundary | |
916 skip_bits_long(&gb, 32 - (get_bits_count(&gb) & 0x1F)); | |
11245
1e9ff636c3db
Make Bink decoder to stop decoding planes after all bits are used.
kostya
parents:
11244
diff
changeset
|
917 if (get_bits_count(&gb) >= bits_count) |
1e9ff636c3db
Make Bink decoder to stop decoding planes after all bits are used.
kostya
parents:
11244
diff
changeset
|
918 break; |
11231 | 919 } |
920 emms_c(); | |
921 | |
922 *data_size = sizeof(AVFrame); | |
923 *(AVFrame*)data = c->pic; | |
924 | |
925 FFSWAP(AVFrame, c->pic, c->last); | |
926 | |
927 /* always report that the buffer was completely consumed */ | |
928 return pkt->size; | |
929 } | |
930 | |
931 static av_cold int decode_init(AVCodecContext *avctx) | |
932 { | |
933 BinkContext * const c = avctx->priv_data; | |
934 static VLC_TYPE table[16 * 128][2]; | |
935 int i; | |
11251
56e65f21e9c5
Bink video decoder now can use extradata to detect alpha plane presence
kostya
parents:
11247
diff
changeset
|
936 int flags; |
11231 | 937 |
938 c->version = avctx->codec_tag >> 24; | |
939 if (c->version < 'c') { | |
940 av_log(avctx, AV_LOG_ERROR, "Too old version '%c'\n", c->version); | |
941 return -1; | |
942 } | |
11251
56e65f21e9c5
Bink video decoder now can use extradata to detect alpha plane presence
kostya
parents:
11247
diff
changeset
|
943 if (avctx->extradata_size < 4) { |
56e65f21e9c5
Bink video decoder now can use extradata to detect alpha plane presence
kostya
parents:
11247
diff
changeset
|
944 av_log(avctx, AV_LOG_ERROR, "Extradata missing or too short\n"); |
56e65f21e9c5
Bink video decoder now can use extradata to detect alpha plane presence
kostya
parents:
11247
diff
changeset
|
945 return -1; |
56e65f21e9c5
Bink video decoder now can use extradata to detect alpha plane presence
kostya
parents:
11247
diff
changeset
|
946 } |
56e65f21e9c5
Bink video decoder now can use extradata to detect alpha plane presence
kostya
parents:
11247
diff
changeset
|
947 flags = AV_RL32(avctx->extradata); |
56e65f21e9c5
Bink video decoder now can use extradata to detect alpha plane presence
kostya
parents:
11247
diff
changeset
|
948 c->has_alpha = flags & BINK_FLAG_ALPHA; |
11231 | 949 c->swap_planes = c->version >= 'i'; |
950 if (!bink_trees[15].table) { | |
951 for (i = 0; i < 16; i++) { | |
952 const int maxbits = bink_tree_lens[i][15]; | |
953 bink_trees[i].table = table + i*128; | |
954 bink_trees[i].table_allocated = 1 << maxbits; | |
955 init_vlc(&bink_trees[i], maxbits, 16, | |
956 bink_tree_lens[i], 1, 1, | |
957 bink_tree_bits[i], 1, 1, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE); | |
958 } | |
959 } | |
960 c->avctx = avctx; | |
961 | |
962 c->pic.data[0] = NULL; | |
963 | |
964 if (avcodec_check_dimensions(avctx, avctx->width, avctx->height) < 0) { | |
965 return 1; | |
966 } | |
967 | |
968 avctx->pix_fmt = PIX_FMT_YUV420P; | |
969 | |
970 avctx->idct_algo = FF_IDCT_BINK; | |
971 dsputil_init(&c->dsp, avctx); | |
972 ff_init_scantable(c->dsp.idct_permutation, &c->scantable, bink_scan); | |
973 | |
974 init_bundles(c); | |
975 | |
976 return 0; | |
977 } | |
978 | |
979 static av_cold int decode_end(AVCodecContext *avctx) | |
980 { | |
981 BinkContext * const c = avctx->priv_data; | |
982 | |
983 if (c->pic.data[0]) | |
984 avctx->release_buffer(avctx, &c->pic); | |
985 if (c->last.data[0]) | |
986 avctx->release_buffer(avctx, &c->last); | |
987 | |
988 free_bundles(c); | |
989 return 0; | |
990 } | |
991 | |
992 AVCodec bink_decoder = { | |
993 "binkvideo", | |
994 CODEC_TYPE_VIDEO, | |
995 CODEC_ID_BINKVIDEO, | |
996 sizeof(BinkContext), | |
997 decode_init, | |
998 NULL, | |
999 decode_end, | |
1000 decode_frame, | |
1001 .long_name = NULL_IF_CONFIG_SMALL("Bink video"), | |
1002 }; |