2 * VC-1 and WMV3 decoder common code
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder common code
29 #include "libavutil/attributes.h"
32 #include "mpegvideo.h"
37 #include "simple_idct.h"
39 /***********************************************************************/
41 * @name VC-1 Bitplane decoding
46 /** Decode rows by checking if they are skipped
47 * @param plane Buffer to store decoded bits
48 * @param[in] width Width of this buffer
49 * @param[in] height Height of this buffer
50 * @param[in] stride of this buffer
52 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
57 for (y = 0; y < height; y++) {
58 if (!get_bits1(gb)) //rowskip
59 memset(plane, 0, width);
61 for (x = 0; x < width; x++)
62 plane[x] = get_bits1(gb);
67 /** Decode columns by checking if they are skipped
68 * @param plane Buffer to store decoded bits
69 * @param[in] width Width of this buffer
70 * @param[in] height Height of this buffer
71 * @param[in] stride of this buffer
72 * @todo FIXME: Optimize
74 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
79 for (x = 0; x < width; x++) {
80 if (!get_bits1(gb)) //colskip
81 for (y = 0; y < height; y++)
84 for (y = 0; y < height; y++)
85 plane[y*stride] = get_bits1(gb);
90 /** Decode a bitplane's bits
91 * @param data bitplane where to store the decode bits
92 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
93 * @param v VC-1 context for bit reading and logging
95 * @todo FIXME: Optimize
97 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
99 GetBitContext *gb = &v->s.gb;
101 int imode, x, y, code, offset;
102 uint8_t invert, *planep = data;
103 int width, height, stride;
105 width = v->s.mb_width;
106 height = v->s.mb_height >> v->field_mode;
107 stride = v->s.mb_stride;
108 invert = get_bits1(gb);
109 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
114 //Data is actually read in the MB layer (same for all tests == "raw")
115 *raw_flag = 1; //invert ignored
119 if ((height * width) & 1) {
120 *planep++ = get_bits1(gb);
122 if (offset == width) {
124 planep += stride - width;
129 // decode bitplane as one long line
130 for (; y < height * width; y += 2) {
131 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
132 *planep++ = code & 1;
134 if (offset == width) {
136 planep += stride - width;
138 *planep++ = code >> 1;
140 if (offset == width) {
142 planep += stride - width;
148 if (!(height % 3) && (width % 3)) { // use 2x3 decoding
149 for (y = 0; y < height; y += 3) {
150 for (x = width & 1; x < width; x += 2) {
151 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
153 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
156 planep[x + 0] = (code >> 0) & 1;
157 planep[x + 1] = (code >> 1) & 1;
158 planep[x + 0 + stride] = (code >> 2) & 1;
159 planep[x + 1 + stride] = (code >> 3) & 1;
160 planep[x + 0 + stride * 2] = (code >> 4) & 1;
161 planep[x + 1 + stride * 2] = (code >> 5) & 1;
163 planep += stride * 3;
166 decode_colskip(data, 1, height, stride, &v->s.gb);
168 planep += (height & 1) * stride;
169 for (y = height & 1; y < height; y += 2) {
170 for (x = width % 3; x < width; x += 3) {
171 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
173 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
176 planep[x + 0] = (code >> 0) & 1;
177 planep[x + 1] = (code >> 1) & 1;
178 planep[x + 2] = (code >> 2) & 1;
179 planep[x + 0 + stride] = (code >> 3) & 1;
180 planep[x + 1 + stride] = (code >> 4) & 1;
181 planep[x + 2 + stride] = (code >> 5) & 1;
183 planep += stride * 2;
187 decode_colskip(data, x, height, stride, &v->s.gb);
189 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
193 decode_rowskip(data, width, height, stride, &v->s.gb);
196 decode_colskip(data, width, height, stride, &v->s.gb);
202 /* Applying diff operator */
203 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
206 for (x = 1; x < width; x++)
207 planep[x] ^= planep[x-1];
208 for (y = 1; y < height; y++) {
210 planep[0] ^= planep[-stride];
211 for (x = 1; x < width; x++) {
212 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
213 else planep[x] ^= planep[x-1];
218 for (x = 0; x < stride * height; x++)
219 planep[x] = !planep[x]; //FIXME stride
221 return (imode << 1) + invert;
224 /** @} */ //Bitplane group
226 /***********************************************************************/
227 /** VOP Dquant decoding
228 * @param v VC-1 Context
230 static int vop_dquant_decoding(VC1Context *v)
232 GetBitContext *gb = &v->s.gb;
236 if (v->dquant != 2) {
237 v->dquantfrm = get_bits1(gb);
241 v->dqprofile = get_bits(gb, 2);
242 switch (v->dqprofile) {
243 case DQPROFILE_SINGLE_EDGE:
244 case DQPROFILE_DOUBLE_EDGES:
245 v->dqsbedge = get_bits(gb, 2);
247 case DQPROFILE_ALL_MBS:
248 v->dqbilevel = get_bits1(gb);
258 pqdiff = get_bits(gb, 3);
260 v->altpq = get_bits(gb, 5);
262 v->altpq = v->pq + pqdiff + 1;
267 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
270 * Decode Simple/Main Profiles sequence header
271 * @see Figure 7-8, p16-17
272 * @param avctx Codec context
273 * @param gb GetBit context initialized from Codec context extra_data
276 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
278 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
279 v->profile = get_bits(gb, 2);
280 if (v->profile == PROFILE_COMPLEX) {
281 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
284 if (v->profile == PROFILE_ADVANCED) {
285 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
286 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
287 return decode_sequence_header_adv(v, gb);
290 v->zz_8x4 = ff_wmv2_scantableA;
291 v->zz_4x8 = ff_wmv2_scantableB;
292 v->res_y411 = get_bits1(gb);
293 v->res_sprite = get_bits1(gb);
295 av_log(avctx, AV_LOG_ERROR,
296 "Old interlaced mode is not supported\n");
302 v->frmrtq_postproc = get_bits(gb, 3); //common
303 // (bitrate-32kbps)/64kbps
304 v->bitrtq_postproc = get_bits(gb, 5); //common
305 v->s.loop_filter = get_bits1(gb); //common
306 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
307 av_log(avctx, AV_LOG_ERROR,
308 "LOOPFILTER shall not be enabled in Simple Profile\n");
310 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
311 v->s.loop_filter = 0;
313 v->res_x8 = get_bits1(gb); //reserved
314 v->multires = get_bits1(gb);
315 v->res_fasttx = get_bits1(gb);
316 if (!v->res_fasttx) {
317 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_int16_8bit;
318 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
319 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
320 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
321 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_int16_8bit;
322 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
323 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
324 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
327 v->fastuvmc = get_bits1(gb); //common
328 if (!v->profile && !v->fastuvmc) {
329 av_log(avctx, AV_LOG_ERROR,
330 "FASTUVMC unavailable in Simple Profile\n");
333 v->extended_mv = get_bits1(gb); //common
334 if (!v->profile && v->extended_mv) {
335 av_log(avctx, AV_LOG_ERROR,
336 "Extended MVs unavailable in Simple Profile\n");
339 v->dquant = get_bits(gb, 2); //common
340 v->vstransform = get_bits1(gb); //common
342 v->res_transtab = get_bits1(gb);
343 if (v->res_transtab) {
344 av_log(avctx, AV_LOG_ERROR,
345 "1 for reserved RES_TRANSTAB is forbidden\n");
349 v->overlap = get_bits1(gb); //common
351 v->resync_marker = get_bits1(gb);
352 v->rangered = get_bits1(gb);
353 if (v->rangered && v->profile == PROFILE_SIMPLE) {
354 av_log(avctx, AV_LOG_INFO,
355 "RANGERED should be set to 0 in Simple Profile\n");
358 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
359 v->quantizer_mode = get_bits(gb, 2); //common
361 v->finterpflag = get_bits1(gb); //common
364 int w = get_bits(gb, 11);
365 int h = get_bits(gb, 11);
366 int ret = ff_set_dimensions(v->s.avctx, w, h);
368 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
371 skip_bits(gb, 5); //frame rate
372 v->res_x8 = get_bits1(gb);
373 if (get_bits1(gb)) { // something to do with DC VLC selection
374 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
377 skip_bits(gb, 3); //slice code
380 v->res_rtm_flag = get_bits1(gb); //reserved
382 if (!v->res_rtm_flag) {
383 av_log(avctx, AV_LOG_ERROR,
384 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
387 //TODO: figure out what they mean (always 0x402F)
390 av_log(avctx, AV_LOG_DEBUG,
391 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
392 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
393 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
394 "DQuant=%i, Quantizer mode=%i, Max B-frames=%i\n",
395 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
396 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
397 v->rangered, v->vstransform, v->overlap, v->resync_marker,
398 v->dquant, v->quantizer_mode, avctx->max_b_frames);
402 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
405 v->level = get_bits(gb, 3);
407 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
409 v->chromaformat = get_bits(gb, 2);
410 if (v->chromaformat != 1) {
411 av_log(v->s.avctx, AV_LOG_ERROR,
412 "Only 4:2:0 chroma format supported\n");
417 v->frmrtq_postproc = get_bits(gb, 3); //common
418 // (bitrate-32kbps)/64kbps
419 v->bitrtq_postproc = get_bits(gb, 5); //common
420 v->postprocflag = get_bits1(gb); //common
422 v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
423 v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
424 v->broadcast = get_bits1(gb);
425 v->interlace = get_bits1(gb);
426 v->tfcntrflag = get_bits1(gb);
427 v->finterpflag = get_bits1(gb);
428 skip_bits1(gb); // reserved
430 av_log(v->s.avctx, AV_LOG_DEBUG,
431 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
432 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
433 "TFCTRflag=%i, FINTERPflag=%i\n",
434 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
435 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
436 v->tfcntrflag, v->finterpflag);
438 v->psf = get_bits1(gb);
439 if (v->psf) { //PsF, 6.1.13
440 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
443 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
444 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
446 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
447 w = get_bits(gb, 14) + 1;
448 h = get_bits(gb, 14) + 1;
449 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
451 ar = get_bits(gb, 4);
453 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
454 } else if (ar == 15) {
455 w = get_bits(gb, 8) + 1;
456 h = get_bits(gb, 8) + 1;
457 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
459 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
460 &v->s.avctx->sample_aspect_ratio.den,
461 v->s.avctx->height * w,
462 v->s.avctx->width * h,
465 ff_set_sar(v->s.avctx, v->s.avctx->sample_aspect_ratio);
466 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
467 v->s.avctx->sample_aspect_ratio.num,
468 v->s.avctx->sample_aspect_ratio.den);
470 if (get_bits1(gb)) { //framerate stuff
472 v->s.avctx->framerate.den = 32;
473 v->s.avctx->framerate.num = get_bits(gb, 16) + 1;
476 nr = get_bits(gb, 8);
477 dr = get_bits(gb, 4);
478 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
479 v->s.avctx->framerate.den = ff_vc1_fps_dr[dr - 1];
480 v->s.avctx->framerate.num = ff_vc1_fps_nr[nr - 1] * 1000;
483 if (v->broadcast) { // Pulldown may be present
484 v->s.avctx->ticks_per_frame = 2;
489 v->color_prim = get_bits(gb, 8);
490 v->transfer_char = get_bits(gb, 8);
491 v->matrix_coef = get_bits(gb, 8);
495 v->hrd_param_flag = get_bits1(gb);
496 if (v->hrd_param_flag) {
498 v->hrd_num_leaky_buckets = get_bits(gb, 5);
499 skip_bits(gb, 4); //bitrate exponent
500 skip_bits(gb, 4); //buffer size exponent
501 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
502 skip_bits(gb, 16); //hrd_rate[n]
503 skip_bits(gb, 16); //hrd_buffer[n]
509 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
515 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
516 v->broken_link = get_bits1(gb);
517 v->closed_entry = get_bits1(gb);
518 v->panscanflag = get_bits1(gb);
519 v->refdist_flag = get_bits1(gb);
520 v->s.loop_filter = get_bits1(gb);
521 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
522 v->s.loop_filter = 0;
523 v->fastuvmc = get_bits1(gb);
524 v->extended_mv = get_bits1(gb);
525 v->dquant = get_bits(gb, 2);
526 v->vstransform = get_bits1(gb);
527 v->overlap = get_bits1(gb);
528 v->quantizer_mode = get_bits(gb, 2);
530 if (v->hrd_param_flag) {
531 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
532 skip_bits(gb, 8); //hrd_full[n]
537 w = (get_bits(gb, 12)+1)<<1;
538 h = (get_bits(gb, 12)+1)<<1;
540 w = v->max_coded_width;
541 h = v->max_coded_height;
543 if ((ret = ff_set_dimensions(avctx, w, h)) < 0) {
544 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
549 v->extended_dmv = get_bits1(gb);
550 if ((v->range_mapy_flag = get_bits1(gb))) {
551 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
552 v->range_mapy = get_bits(gb, 3);
554 if ((v->range_mapuv_flag = get_bits1(gb))) {
555 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
556 v->range_mapuv = get_bits(gb, 3);
559 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
560 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
561 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
562 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
563 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
564 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
569 /* fill lookup tables for intensity compensation */
570 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \
571 int scale, shift, i; \
574 shift = (255 - lumshift * 2) * 64; \
578 scale = lumscale + 32; \
580 shift = (lumshift - 64) * 64; \
582 shift = lumshift << 6; \
584 for (i = 0; i < 256; i++) { \
585 int iy = chain ? luty[i] : i; \
586 int iu = chain ? lutuv[i] : i; \
587 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
588 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
592 static void rotate_luts(VC1Context *v)
594 #define ROTATE(DEF, L, N, C, A) do { \
595 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
599 memcpy(&tmp, L , sizeof(tmp)); \
600 memcpy(L , N , sizeof(tmp)); \
601 memcpy(N , &tmp, sizeof(tmp)); \
606 ROTATE(int tmp, &v->last_use_ic, &v->next_use_ic, v->curr_use_ic, &v->aux_use_ic);
607 ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
608 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
610 INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
611 INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
615 static int read_bfraction(VC1Context *v, GetBitContext* gb) {
616 int bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
618 if (bfraction_lut_index == 21 || bfraction_lut_index < 0) {
619 av_log(v->s.avctx, AV_LOG_ERROR, "bfraction invalid\n");
620 return AVERROR_INVALIDDATA;
622 v->bfraction_lut_index = bfraction_lut_index;
623 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
627 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
629 int pqindex, lowquant, status;
632 v->fcm = PROGRESSIVE;
634 v->interpfrm = get_bits1(gb);
635 if (!v->s.avctx->codec)
637 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
640 v->multires = get_bits(gb, 2) == 1;
642 skip_bits(gb, 2); //framecnt unused
645 v->rangeredfrm = get_bits1(gb);
647 v->s.pict_type = AV_PICTURE_TYPE_P;
649 if (v->s.avctx->max_b_frames && !get_bits1(gb)) {
650 v->s.pict_type = AV_PICTURE_TYPE_B;
652 v->s.pict_type = AV_PICTURE_TYPE_I;
656 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
657 if (read_bfraction(v, gb) < 0)
658 return AVERROR_INVALIDDATA;
659 if (v->bfraction == 0) {
660 v->s.pict_type = AV_PICTURE_TYPE_BI;
663 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
664 skip_bits(gb, 7); // skip buffer fullness
670 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
672 if (v->s.pict_type == AV_PICTURE_TYPE_P)
675 /* Quantizer stuff */
676 pqindex = get_bits(gb, 5);
679 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
680 v->pq = ff_vc1_pquant_table[0][pqindex];
682 v->pq = ff_vc1_pquant_table[1][pqindex];
683 v->pqindex = pqindex;
685 v->halfpq = get_bits1(gb);
688 switch (v->quantizer_mode) {
689 case QUANT_FRAME_IMPLICIT:
690 v->pquantizer = pqindex < 9;
692 case QUANT_NON_UNIFORM:
695 case QUANT_FRAME_EXPLICIT:
696 v->pquantizer = get_bits1(gb);
703 if (v->extended_mv == 1)
704 v->mvrange = get_unary(gb, 0, 3);
705 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
706 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
707 v->range_x = 1 << (v->k_x - 1);
708 v->range_y = 1 << (v->k_y - 1);
709 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
710 v->respic = get_bits(gb, 2);
712 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
713 v->x8_type = get_bits1(gb);
716 ff_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
717 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
718 pqindex, v->pq, v->halfpq, v->rangeredfrm);
720 if (v->first_pic_header_flag)
723 switch (v->s.pict_type) {
724 case AV_PICTURE_TYPE_P:
725 v->tt_index = (v->pq > 4) + (v->pq > 12);
727 lowquant = (v->pq > 12) ? 0 : 1;
728 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
729 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
730 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
731 v->lumscale = get_bits(gb, 6);
732 v->lumshift = get_bits(gb, 6);
734 /* fill lookup tables for intensity compensation */
735 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
736 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
738 v->qs_last = v->s.quarter_sample;
739 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
740 v->s.quarter_sample = (v->mv_mode2 != MV_PMODE_1MV_HPEL &&
741 v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
742 v->s.mspel = (v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
744 v->s.quarter_sample = (v->mv_mode != MV_PMODE_1MV_HPEL &&
745 v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
746 v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
749 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
750 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
751 v->mv_mode == MV_PMODE_MIXED_MV) {
752 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
755 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
756 "Imode: %i, Invert: %i\n", status>>1, status&1);
758 v->mv_type_is_raw = 0;
759 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
761 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
764 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
765 "Imode: %i, Invert: %i\n", status>>1, status&1);
767 /* Hopefully this is correct for P-frames */
768 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
769 v->cbptab = get_bits(gb, 2);
770 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
773 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
774 vop_dquant_decoding(v);
777 if (v->vstransform) {
778 v->ttmbf = get_bits1(gb);
780 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
782 v->ttfrm = 0; //FIXME Is that so ?
788 case AV_PICTURE_TYPE_B:
789 v->tt_index = (v->pq > 4) + (v->pq > 12);
791 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
792 v->qs_last = v->s.quarter_sample;
793 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
794 v->s.mspel = v->s.quarter_sample;
796 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
799 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
800 "Imode: %i, Invert: %i\n", status>>1, status&1);
801 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
804 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
805 "Imode: %i, Invert: %i\n", status>>1, status&1);
807 v->s.mv_table_index = get_bits(gb, 2);
808 v->cbptab = get_bits(gb, 2);
809 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
812 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
813 vop_dquant_decoding(v);
816 if (v->vstransform) {
817 v->ttmbf = get_bits1(gb);
819 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
831 v->c_ac_table_index = decode012(gb);
832 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
833 v->y_ac_table_index = decode012(gb);
836 v->s.dc_table_index = get_bits1(gb);
839 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
840 v->s.pict_type = AV_PICTURE_TYPE_B;
846 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
848 int pqindex, lowquant;
853 v->p_frame_skipped = 0;
854 if (v->second_field) {
855 if (v->fcm != ILACE_FIELD || v->field_mode!=1)
858 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
860 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
861 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
862 if (!v->pic_header_flag)
863 goto parse_common_info;
870 if (fcm == ILACE_FIELD)
876 if (!v->first_pic_header_flag && v->field_mode != field_mode)
877 return AVERROR_INVALIDDATA;
878 v->field_mode = field_mode;
881 av_assert0( v->s.mb_height == v->s.height + 15 >> 4
882 || v->s.mb_height == FFALIGN(v->s.height + 15 >> 4, 2));
884 v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
885 v->fptype = get_bits(gb, 3);
886 if (v->fptype & 4) // B-picture
887 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
889 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
891 v->s.mb_height = v->s.height + 15 >> 4;
892 switch (get_unary(gb, 0, 4)) {
894 v->s.pict_type = AV_PICTURE_TYPE_P;
897 v->s.pict_type = AV_PICTURE_TYPE_B;
900 v->s.pict_type = AV_PICTURE_TYPE_I;
903 v->s.pict_type = AV_PICTURE_TYPE_BI;
906 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
907 v->p_frame_skipped = 1;
914 if (!v->interlace || v->psf) {
915 v->rptfrm = get_bits(gb, 2);
917 v->tff = get_bits1(gb);
918 v->rff = get_bits1(gb);
923 if (v->panscanflag) {
924 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
927 if (v->p_frame_skipped) {
930 v->rnd = get_bits1(gb);
932 v->uvsamp = get_bits1(gb);
933 if(!ff_vc1_bfraction_vlc.table)
934 return 0; //parsing only, vlc tables havnt been allocated
936 if (!v->refdist_flag)
938 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
939 v->refdist = get_bits(gb, 2);
941 v->refdist += get_unary(gb, 0, 16);
943 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
944 if (read_bfraction(v, gb) < 0)
945 return AVERROR_INVALIDDATA;
946 v->frfd = (v->bfraction * v->refdist) >> 8;
947 v->brfd = v->refdist - v->frfd - 1;
951 goto parse_common_info;
953 if (v->fcm == PROGRESSIVE) {
955 v->interpfrm = get_bits1(gb);
956 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
957 if (read_bfraction(v, gb) < 0)
958 return AVERROR_INVALIDDATA;
959 if (v->bfraction == 0) {
960 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
967 v->cur_field_type = !(v->tff ^ v->second_field);
968 pqindex = get_bits(gb, 5);
971 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
972 v->pq = ff_vc1_pquant_table[0][pqindex];
974 v->pq = ff_vc1_pquant_table[1][pqindex];
975 v->pqindex = pqindex;
977 v->halfpq = get_bits1(gb);
980 switch (v->quantizer_mode) {
981 case QUANT_FRAME_IMPLICIT:
982 v->pquantizer = pqindex < 9;
984 case QUANT_NON_UNIFORM:
987 case QUANT_FRAME_EXPLICIT:
988 v->pquantizer = get_bits1(gb);
996 v->postproc = get_bits(gb, 2);
1001 if (v->first_pic_header_flag)
1004 switch (v->s.pict_type) {
1005 case AV_PICTURE_TYPE_I:
1006 case AV_PICTURE_TYPE_BI:
1007 if (v->fcm == ILACE_FRAME) { //interlace frame picture
1008 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
1011 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1012 "Imode: %i, Invert: %i\n", status>>1, status&1);
1014 v->fieldtx_is_raw = 0;
1015 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1018 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1019 "Imode: %i, Invert: %i\n", status>>1, status&1);
1020 v->condover = CONDOVER_NONE;
1021 if (v->overlap && v->pq <= 8) {
1022 v->condover = decode012(gb);
1023 if (v->condover == CONDOVER_SELECT) {
1024 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1027 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1028 "Imode: %i, Invert: %i\n", status>>1, status&1);
1032 case AV_PICTURE_TYPE_P:
1033 if (v->field_mode) {
1034 v->numref = get_bits1(gb);
1036 v->reffield = get_bits1(gb);
1037 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1041 v->mvrange = get_unary(gb, 0, 3);
1045 if (v->extended_dmv)
1046 v->dmvrange = get_unary(gb, 0, 3);
1049 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1050 v->fourmvswitch = get_bits1(gb);
1051 v->intcomp = get_bits1(gb);
1053 v->lumscale = get_bits(gb, 6);
1054 v->lumshift = get_bits(gb, 6);
1055 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1056 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1059 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1062 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1063 "Imode: %i, Invert: %i\n", status>>1, status&1);
1064 v->mbmodetab = get_bits(gb, 2);
1065 if (v->fourmvswitch)
1066 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[v->mbmodetab];
1068 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[v->mbmodetab];
1069 v->imvtab = get_bits(gb, 2);
1070 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1071 // interlaced p-picture cbpcy range is [1, 63]
1072 v->icbptab = get_bits(gb, 3);
1073 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1074 v->twomvbptab = get_bits(gb, 2);
1075 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[v->twomvbptab];
1076 if (v->fourmvswitch) {
1077 v->fourmvbptab = get_bits(gb, 2);
1078 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1082 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1083 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1084 v->range_x = 1 << (v->k_x - 1);
1085 v->range_y = 1 << (v->k_y - 1);
1087 v->tt_index = (v->pq > 4) + (v->pq > 12);
1088 if (v->fcm != ILACE_FRAME) {
1090 mvmode = get_unary(gb, 1, 4);
1091 lowquant = (v->pq > 12) ? 0 : 1;
1092 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1093 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1095 mvmode2 = get_unary(gb, 1, 3);
1096 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1097 if (v->field_mode) {
1098 v->intcompfield = decode210(gb) ^ 3;
1100 v->intcompfield = 3;
1102 v->lumscale2 = v->lumscale = 32;
1103 v->lumshift2 = v->lumshift = 0;
1104 if (v->intcompfield & 1) {
1105 v->lumscale = get_bits(gb, 6);
1106 v->lumshift = get_bits(gb, 6);
1108 if ((v->intcompfield & 2) && v->field_mode) {
1109 v->lumscale2 = get_bits(gb, 6);
1110 v->lumshift2 = get_bits(gb, 6);
1111 } else if(!v->field_mode) {
1112 v->lumscale2 = v->lumscale;
1113 v->lumshift2 = v->lumshift;
1115 if (v->field_mode && v->second_field) {
1116 if (v->cur_field_type) {
1117 INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1118 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1120 INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1121 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1123 v->next_use_ic = *v->curr_use_ic = 1;
1125 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1126 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1130 v->qs_last = v->s.quarter_sample;
1131 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1132 v->s.quarter_sample = (v->mv_mode2 != MV_PMODE_1MV_HPEL &&
1133 v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
1134 v->s.mspel = (v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
1136 v->s.quarter_sample = (v->mv_mode != MV_PMODE_1MV_HPEL &&
1137 v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1138 v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1141 if (v->fcm == PROGRESSIVE) { // progressive
1142 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1143 v->mv_mode2 == MV_PMODE_MIXED_MV)
1144 || v->mv_mode == MV_PMODE_MIXED_MV) {
1145 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1148 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1149 "Imode: %i, Invert: %i\n", status>>1, status&1);
1151 v->mv_type_is_raw = 0;
1152 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1154 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1157 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1158 "Imode: %i, Invert: %i\n", status>>1, status&1);
1160 /* Hopefully this is correct for P-frames */
1161 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1162 v->cbptab = get_bits(gb, 2);
1163 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
1164 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1165 v->qs_last = v->s.quarter_sample;
1166 v->s.quarter_sample = 1;
1168 } else { // field interlaced
1169 v->mbmodetab = get_bits(gb, 3);
1170 v->imvtab = get_bits(gb, 2 + v->numref);
1172 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1174 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[v->imvtab];
1175 v->icbptab = get_bits(gb, 3);
1176 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1177 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1178 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1179 v->fourmvbptab = get_bits(gb, 2);
1180 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1181 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[v->mbmodetab];
1183 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[v->mbmodetab];
1187 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1188 vop_dquant_decoding(v);
1191 if (v->vstransform) {
1192 v->ttmbf = get_bits1(gb);
1194 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1196 v->ttfrm = 0; //FIXME Is that so ?
1202 case AV_PICTURE_TYPE_B:
1203 if (v->fcm == ILACE_FRAME) {
1204 if (read_bfraction(v, gb) < 0)
1205 return AVERROR_INVALIDDATA;
1206 if (v->bfraction == 0) {
1211 v->mvrange = get_unary(gb, 0, 3);
1214 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1215 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1216 v->range_x = 1 << (v->k_x - 1);
1217 v->range_y = 1 << (v->k_y - 1);
1219 v->tt_index = (v->pq > 4) + (v->pq > 12);
1221 if (v->field_mode) {
1223 av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1224 if (v->extended_dmv)
1225 v->dmvrange = get_unary(gb, 0, 3);
1226 mvmode = get_unary(gb, 1, 3);
1227 lowquant = (v->pq > 12) ? 0 : 1;
1228 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1229 v->qs_last = v->s.quarter_sample;
1230 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1231 v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1232 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1235 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1236 "Imode: %i, Invert: %i\n", status>>1, status&1);
1237 v->mbmodetab = get_bits(gb, 3);
1238 if (v->mv_mode == MV_PMODE_MIXED_MV)
1239 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[v->mbmodetab];
1241 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[v->mbmodetab];
1242 v->imvtab = get_bits(gb, 3);
1243 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[v->imvtab];
1244 v->icbptab = get_bits(gb, 3);
1245 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1246 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1247 v->fourmvbptab = get_bits(gb, 2);
1248 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1250 v->numref = 1; // interlaced field B pictures are always 2-ref
1251 } else if (v->fcm == ILACE_FRAME) {
1252 if (v->extended_dmv)
1253 v->dmvrange = get_unary(gb, 0, 3);
1254 if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1255 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1257 v->mv_mode = MV_PMODE_1MV;
1258 v->fourmvswitch = 0;
1259 v->qs_last = v->s.quarter_sample;
1260 v->s.quarter_sample = 1;
1262 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1265 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1266 "Imode: %i, Invert: %i\n", status>>1, status&1);
1267 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1270 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1271 "Imode: %i, Invert: %i\n", status>>1, status&1);
1272 v->mbmodetab = get_bits(gb, 2);
1273 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[v->mbmodetab];
1274 v->imvtab = get_bits(gb, 2);
1275 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1276 // interlaced p/b-picture cbpcy range is [1, 63]
1277 v->icbptab = get_bits(gb, 3);
1278 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1279 v->twomvbptab = get_bits(gb, 2);
1280 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[v->twomvbptab];
1281 v->fourmvbptab = get_bits(gb, 2);
1282 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1284 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1285 v->qs_last = v->s.quarter_sample;
1286 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1287 v->s.mspel = v->s.quarter_sample;
1288 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1291 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1292 "Imode: %i, Invert: %i\n", status>>1, status&1);
1293 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1296 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1297 "Imode: %i, Invert: %i\n", status>>1, status&1);
1298 v->s.mv_table_index = get_bits(gb, 2);
1299 v->cbptab = get_bits(gb, 2);
1300 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
1304 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1305 vop_dquant_decoding(v);
1308 if (v->vstransform) {
1309 v->ttmbf = get_bits1(gb);
1311 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1321 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1327 v->c_ac_table_index = decode012(gb);
1328 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1329 v->y_ac_table_index = decode012(gb);
1332 v->s.dc_table_index = get_bits1(gb);
1333 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1335 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1336 vop_dquant_decoding(v);
1339 v->bi_type = (v->s.pict_type == AV_PICTURE_TYPE_BI);
1341 v->s.pict_type = AV_PICTURE_TYPE_B;
1346 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1348 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1349 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1350 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1351 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1352 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1353 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1354 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1355 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1356 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1357 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1358 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1359 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1360 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1361 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1362 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1363 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1364 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1365 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1366 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1367 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1368 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1369 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1370 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1371 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1372 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1373 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1374 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1375 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1376 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1377 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1378 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1381 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1382 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1383 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1384 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1385 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1386 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1387 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1388 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1389 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1390 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1391 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1392 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1393 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1394 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1395 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1396 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1397 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1398 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1399 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1400 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1401 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1402 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1403 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1404 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1405 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1406 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1407 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1408 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1412 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1413 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1414 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1415 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1416 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1417 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1418 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1419 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1420 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1421 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1422 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1423 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1424 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1425 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1426 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1427 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1428 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1429 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1430 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1431 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1432 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1433 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1437 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1438 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1439 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1440 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1441 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1442 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1443 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1444 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1445 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1446 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1447 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1448 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1449 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1450 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1451 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1452 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1453 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1454 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1455 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1456 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1457 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1458 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1459 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1460 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1461 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1464 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1465 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1466 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1467 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1468 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1469 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1470 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1471 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1472 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1473 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1474 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1475 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1476 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1477 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1478 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1479 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1480 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1484 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1485 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1486 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1487 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1488 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1489 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1490 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1491 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1492 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1493 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1494 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1495 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1496 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1497 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1498 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1499 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1500 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1504 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1505 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1506 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1507 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1508 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1509 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1510 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1511 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1512 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1513 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1514 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1515 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1516 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1517 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1518 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1519 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1520 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1521 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1522 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1523 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1524 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1525 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1526 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1527 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1528 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1529 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1530 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1534 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1535 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1536 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1537 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1538 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1539 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1540 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1541 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1542 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1543 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1544 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1545 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1546 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1547 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1548 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1549 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1550 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1551 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1552 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1553 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1554 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1555 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1556 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1557 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1558 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1559 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1560 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1561 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1562 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1567 static const uint16_t vlc_offs[] = {
1568 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1569 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1570 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1571 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1572 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1573 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1574 31714, 31746, 31778, 32306, 32340, 32372
1578 * Init VC-1 specific tables and VC1Context members
1579 * @param v The VC1Context to initialize
1582 av_cold int ff_vc1_init_common(VC1Context *v)
1584 static int done = 0;
1586 static VLC_TYPE vlc_table[32372][2];
1588 v->hrd_rate = v->hrd_buffer = NULL;
1592 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1593 ff_vc1_bfraction_bits, 1, 1,
1594 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1595 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1596 ff_vc1_norm2_bits, 1, 1,
1597 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1598 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1599 ff_vc1_norm6_bits, 1, 1,
1600 ff_vc1_norm6_codes, 2, 2, 556);
1601 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1602 ff_vc1_imode_bits, 1, 1,
1603 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1604 for (i = 0; i < 3; i++) {
1605 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1606 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1607 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1608 ff_vc1_ttmb_bits[i], 1, 1,
1609 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1610 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1611 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1612 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1613 ff_vc1_ttblk_bits[i], 1, 1,
1614 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1615 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1616 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1617 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1618 ff_vc1_subblkpat_bits[i], 1, 1,
1619 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1621 for (i = 0; i < 4; i++) {
1622 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1623 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1624 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1625 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1626 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1627 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1628 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1629 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1630 ff_vc1_cbpcy_p_bits[i], 1, 1,
1631 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1632 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1633 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1634 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1635 ff_vc1_mv_diff_bits[i], 1, 1,
1636 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1638 for (i = 0; i < 8; i++) {
1639 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1640 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1641 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1642 &vc1_ac_tables[i][0][1], 8, 4,
1643 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1644 /* initialize interlaced MVDATA tables (2-Ref) */
1645 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1646 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1647 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1648 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1649 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1651 for (i = 0; i < 4; i++) {
1652 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1653 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1654 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1655 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1656 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1657 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1658 /* initialize NON-4MV MBMODE VLC tables for the same */
1659 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1660 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1661 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1662 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1663 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1664 /* initialize interlaced MVDATA tables (1-Ref) */
1665 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1666 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1667 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1668 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1669 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1671 for (i = 0; i < 4; i++) {
1672 /* Initialize 2MV Block pattern VLC tables */
1673 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1674 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1675 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1676 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1677 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1679 for (i = 0; i < 8; i++) {
1680 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1681 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1682 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1683 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1684 ff_vc1_icbpcy_p_bits[i], 1, 1,
1685 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1686 /* Initialize interlaced field picture MBMODE VLC tables */
1687 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1688 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1689 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1690 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1691 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1692 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1693 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1694 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1695 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1696 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1701 /* Other defaults */
1703 v->mvrange = 0; /* 7.1.1.18, p80 */
1705 ff_vc1dsp_init(&v->vc1dsp);