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
32 #include "mpegvideo.h"
35 #include "msmpeg4data.h"
37 #include "simple_idct.h"
42 /***********************************************************************/
44 * @name VC-1 Bitplane decoding
62 /** @} */ //imode defines
64 /** Decode rows by checking if they are skipped
65 * @param plane Buffer to store decoded bits
66 * @param[in] width Width of this buffer
67 * @param[in] height Height of this buffer
68 * @param[in] stride of this buffer
70 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
75 for (y = 0; y < height; y++) {
76 if (!get_bits1(gb)) //rowskip
77 memset(plane, 0, width);
79 for (x = 0; x < width; x++)
80 plane[x] = get_bits1(gb);
85 /** Decode columns by checking if they are skipped
86 * @param plane Buffer to store decoded bits
87 * @param[in] width Width of this buffer
88 * @param[in] height Height of this buffer
89 * @param[in] stride of this buffer
90 * @todo FIXME: Optimize
92 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
97 for (x = 0; x < width; x++) {
98 if (!get_bits1(gb)) //colskip
99 for (y = 0; y < height; y++)
102 for (y = 0; y < height; y++)
103 plane[y*stride] = get_bits1(gb);
108 /** Decode a bitplane's bits
109 * @param data bitplane where to store the decode bits
110 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
111 * @param v VC-1 context for bit reading and logging
113 * @todo FIXME: Optimize
115 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
117 GetBitContext *gb = &v->s.gb;
119 int imode, x, y, code, offset;
120 uint8_t invert, *planep = data;
121 int width, height, stride;
123 width = v->s.mb_width;
124 height = v->s.mb_height >> v->field_mode;
125 stride = v->s.mb_stride;
126 invert = get_bits1(gb);
127 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
132 //Data is actually read in the MB layer (same for all tests == "raw")
133 *raw_flag = 1; //invert ignored
137 if ((height * width) & 1) {
138 *planep++ = get_bits1(gb);
143 // decode bitplane as one long line
144 for (y = offset; y < height * width; y += 2) {
145 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
146 *planep++ = code & 1;
148 if (offset == width) {
150 planep += stride - width;
152 *planep++ = code >> 1;
154 if (offset == width) {
156 planep += stride - width;
162 if (!(height % 3) && (width % 3)) { // use 2x3 decoding
163 for (y = 0; y < height; y += 3) {
164 for (x = width & 1; x < width; x += 2) {
165 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
167 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
170 planep[x + 0] = (code >> 0) & 1;
171 planep[x + 1] = (code >> 1) & 1;
172 planep[x + 0 + stride] = (code >> 2) & 1;
173 planep[x + 1 + stride] = (code >> 3) & 1;
174 planep[x + 0 + stride * 2] = (code >> 4) & 1;
175 planep[x + 1 + stride * 2] = (code >> 5) & 1;
177 planep += stride * 3;
180 decode_colskip(data, 1, height, stride, &v->s.gb);
182 planep += (height & 1) * stride;
183 for (y = height & 1; y < height; y += 2) {
184 for (x = width % 3; x < width; x += 3) {
185 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
187 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
190 planep[x + 0] = (code >> 0) & 1;
191 planep[x + 1] = (code >> 1) & 1;
192 planep[x + 2] = (code >> 2) & 1;
193 planep[x + 0 + stride] = (code >> 3) & 1;
194 planep[x + 1 + stride] = (code >> 4) & 1;
195 planep[x + 2 + stride] = (code >> 5) & 1;
197 planep += stride * 2;
201 decode_colskip(data, x, height, stride, &v->s.gb);
203 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
207 decode_rowskip(data, width, height, stride, &v->s.gb);
210 decode_colskip(data, width, height, stride, &v->s.gb);
216 /* Applying diff operator */
217 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
220 for (x = 1; x < width; x++)
221 planep[x] ^= planep[x-1];
222 for (y = 1; y < height; y++) {
224 planep[0] ^= planep[-stride];
225 for (x = 1; x < width; x++) {
226 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
227 else planep[x] ^= planep[x-1];
232 for (x = 0; x < stride * height; x++)
233 planep[x] = !planep[x]; //FIXME stride
235 return (imode << 1) + invert;
238 /** @} */ //Bitplane group
240 /***********************************************************************/
241 /** VOP Dquant decoding
242 * @param v VC-1 Context
244 static int vop_dquant_decoding(VC1Context *v)
246 GetBitContext *gb = &v->s.gb;
250 if (v->dquant == 2) {
251 pqdiff = get_bits(gb, 3);
253 v->altpq = get_bits(gb, 5);
255 v->altpq = v->pq + pqdiff + 1;
257 v->dquantfrm = get_bits1(gb);
259 v->dqprofile = get_bits(gb, 2);
260 switch (v->dqprofile) {
261 case DQPROFILE_SINGLE_EDGE:
262 case DQPROFILE_DOUBLE_EDGES:
263 v->dqsbedge = get_bits(gb, 2);
265 case DQPROFILE_ALL_MBS:
266 v->dqbilevel = get_bits1(gb);
272 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
273 pqdiff = get_bits(gb, 3);
275 v->altpq = get_bits(gb, 5);
277 v->altpq = v->pq + pqdiff + 1;
284 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
287 * Decode Simple/Main Profiles sequence header
288 * @see Figure 7-8, p16-17
289 * @param avctx Codec context
290 * @param gb GetBit context initialized from Codec context extra_data
293 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
295 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
296 v->profile = get_bits(gb, 2);
297 if (v->profile == PROFILE_COMPLEX) {
298 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
301 if (v->profile == PROFILE_ADVANCED) {
302 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
303 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
304 return decode_sequence_header_adv(v, gb);
306 v->zz_8x4 = ff_wmv2_scantableA;
307 v->zz_4x8 = ff_wmv2_scantableB;
308 v->res_y411 = get_bits1(gb);
309 v->res_sprite = get_bits1(gb);
311 av_log(avctx, AV_LOG_ERROR,
312 "Old interlaced mode is not supported\n");
318 v->frmrtq_postproc = get_bits(gb, 3); //common
319 // (bitrate-32kbps)/64kbps
320 v->bitrtq_postproc = get_bits(gb, 5); //common
321 v->s.loop_filter = get_bits1(gb); //common
322 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
323 av_log(avctx, AV_LOG_ERROR,
324 "LOOPFILTER shall not be enabled in Simple Profile\n");
326 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
327 v->s.loop_filter = 0;
329 v->res_x8 = get_bits1(gb); //reserved
330 v->multires = get_bits1(gb);
331 v->res_fasttx = get_bits1(gb);
332 if (!v->res_fasttx) {
333 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;
334 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
335 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
336 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
337 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
338 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
339 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
340 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
343 v->fastuvmc = get_bits1(gb); //common
344 if (!v->profile && !v->fastuvmc) {
345 av_log(avctx, AV_LOG_ERROR,
346 "FASTUVMC unavailable in Simple Profile\n");
349 v->extended_mv = get_bits1(gb); //common
350 if (!v->profile && v->extended_mv)
352 av_log(avctx, AV_LOG_ERROR,
353 "Extended MVs unavailable in Simple Profile\n");
356 v->dquant = get_bits(gb, 2); //common
357 v->vstransform = get_bits1(gb); //common
359 v->res_transtab = get_bits1(gb);
362 av_log(avctx, AV_LOG_ERROR,
363 "1 for reserved RES_TRANSTAB is forbidden\n");
367 v->overlap = get_bits1(gb); //common
369 v->s.resync_marker = get_bits1(gb);
370 v->rangered = get_bits1(gb);
371 if (v->rangered && v->profile == PROFILE_SIMPLE) {
372 av_log(avctx, AV_LOG_INFO,
373 "RANGERED should be set to 0 in Simple Profile\n");
376 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
377 v->quantizer_mode = get_bits(gb, 2); //common
379 v->finterpflag = get_bits1(gb); //common
382 int w = get_bits(gb, 11);
383 int h = get_bits(gb, 11);
384 avcodec_set_dimensions(v->s.avctx, w, h);
385 skip_bits(gb, 5); //frame rate
386 v->res_x8 = get_bits1(gb);
387 if (get_bits1(gb)) { // something to do with DC VLC selection
388 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
391 skip_bits(gb, 3); //slice code
394 v->res_rtm_flag = get_bits1(gb); //reserved
396 if (!v->res_rtm_flag) {
397 av_log(avctx, AV_LOG_ERROR,
398 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
401 //TODO: figure out what they mean (always 0x402F)
404 av_log(avctx, AV_LOG_DEBUG,
405 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
406 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
407 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
408 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
409 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
410 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
411 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
412 v->dquant, v->quantizer_mode, avctx->max_b_frames);
416 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
419 v->level = get_bits(gb, 3);
421 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
423 v->chromaformat = get_bits(gb, 2);
424 if (v->chromaformat != 1) {
425 av_log(v->s.avctx, AV_LOG_ERROR,
426 "Only 4:2:0 chroma format supported\n");
431 v->frmrtq_postproc = get_bits(gb, 3); //common
432 // (bitrate-32kbps)/64kbps
433 v->bitrtq_postproc = get_bits(gb, 5); //common
434 v->postprocflag = get_bits1(gb); //common
436 v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
437 v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
438 v->broadcast = get_bits1(gb);
439 v->interlace = get_bits1(gb);
440 v->tfcntrflag = get_bits1(gb);
441 v->finterpflag = get_bits1(gb);
442 skip_bits1(gb); // reserved
444 av_log(v->s.avctx, AV_LOG_DEBUG,
445 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
446 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
447 "TFCTRflag=%i, FINTERPflag=%i\n",
448 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
449 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
450 v->tfcntrflag, v->finterpflag);
452 v->psf = get_bits1(gb);
453 if (v->psf) { //PsF, 6.1.13
454 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
457 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
458 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
460 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
461 w = get_bits(gb, 14) + 1;
462 h = get_bits(gb, 14) + 1;
463 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
465 ar = get_bits(gb, 4);
467 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
468 } else if (ar == 15) {
469 w = get_bits(gb, 8) + 1;
470 h = get_bits(gb, 8) + 1;
471 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
473 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
474 &v->s.avctx->sample_aspect_ratio.den,
475 v->s.avctx->height * w,
476 v->s.avctx->width * h,
479 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
480 v->s.avctx->sample_aspect_ratio.num,
481 v->s.avctx->sample_aspect_ratio.den);
483 if (get_bits1(gb)) { //framerate stuff
485 v->s.avctx->time_base.num = 32;
486 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
489 nr = get_bits(gb, 8);
490 dr = get_bits(gb, 4);
491 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
492 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
493 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
496 if (v->broadcast) { // Pulldown may be present
497 v->s.avctx->time_base.den *= 2;
498 v->s.avctx->ticks_per_frame = 2;
503 v->s.avctx->color_primaries = get_bits(gb, 8);
504 v->s.avctx->color_trc = get_bits(gb, 8);
505 v->s.avctx->colorspace = get_bits(gb, 8);
506 v->s.avctx->color_range = AVCOL_RANGE_MPEG;
510 v->hrd_param_flag = get_bits1(gb);
511 if (v->hrd_param_flag) {
513 v->hrd_num_leaky_buckets = get_bits(gb, 5);
514 skip_bits(gb, 4); //bitrate exponent
515 skip_bits(gb, 4); //buffer size exponent
516 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
517 skip_bits(gb, 16); //hrd_rate[n]
518 skip_bits(gb, 16); //hrd_buffer[n]
524 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
529 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
530 v->broken_link = get_bits1(gb);
531 v->closed_entry = get_bits1(gb);
532 v->panscanflag = get_bits1(gb);
533 v->refdist_flag = get_bits1(gb);
534 v->s.loop_filter = get_bits1(gb);
535 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
536 v->s.loop_filter = 0;
537 v->fastuvmc = get_bits1(gb);
538 v->extended_mv = get_bits1(gb);
539 v->dquant = get_bits(gb, 2);
540 v->vstransform = get_bits1(gb);
541 v->overlap = get_bits1(gb);
542 v->quantizer_mode = get_bits(gb, 2);
544 if (v->hrd_param_flag) {
545 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
546 skip_bits(gb, 8); //hrd_full[n]
551 w = (get_bits(gb, 12)+1)<<1;
552 h = (get_bits(gb, 12)+1)<<1;
554 w = v->max_coded_width;
555 h = v->max_coded_height;
557 avcodec_set_dimensions(avctx, w, h);
559 v->extended_dmv = get_bits1(gb);
560 if ((v->range_mapy_flag = get_bits1(gb))) {
561 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
562 v->range_mapy = get_bits(gb, 3);
564 if ((v->range_mapuv_flag = get_bits1(gb))) {
565 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
566 v->range_mapuv = get_bits(gb, 3);
569 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
570 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
571 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
572 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
573 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
574 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
579 /* fill lookup tables for intensity compensation */
580 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do {\
581 int scale, shift, i; \
584 shift = (255 - lumshift * 2) << 6; \
588 scale = lumscale + 32; \
590 shift = (lumshift - 64) << 6; \
592 shift = lumshift << 6; \
594 for (i = 0; i < 256; i++) { \
595 int iy = chain ? luty[i] : i; \
596 int iu = chain ? lutuv[i] : i; \
597 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
598 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6); \
603 static void rotate_luts(VC1Context *v)
605 #define ROTATE(DEF, L, N, C, A) do {\
606 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) {\
610 memcpy(&tmp, &L , sizeof(tmp));\
611 memcpy(&L , &N , sizeof(tmp));\
612 memcpy(&N , &tmp, sizeof(tmp));\
617 ROTATE(int tmp , v->last_use_ic, v->next_use_ic, v->curr_use_ic, v->aux_use_ic);
618 ROTATE(uint8_t tmp[2][256], v->last_luty , v->next_luty , v->curr_luty , v->aux_luty);
619 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
621 INIT_LUT(32, 0 , v->curr_luty[0] , v->curr_lutuv[0] , 0);
622 INIT_LUT(32, 0 , v->curr_luty[1] , v->curr_lutuv[1] , 0);
626 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
628 int pqindex, lowquant, status;
631 v->interpfrm = get_bits1(gb);
632 if (!v->s.avctx->codec)
634 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
637 v->multires = get_bits(gb, 2) == 1;
639 skip_bits(gb, 2); //framecnt unused
642 v->rangeredfrm = get_bits1(gb);
643 v->s.pict_type = get_bits1(gb);
644 if (v->s.avctx->max_b_frames) {
645 if (!v->s.pict_type) {
647 v->s.pict_type = AV_PICTURE_TYPE_I;
649 v->s.pict_type = AV_PICTURE_TYPE_B;
651 v->s.pict_type = AV_PICTURE_TYPE_P;
653 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
656 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
657 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
658 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
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];
685 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
686 v->pquantizer = pqindex < 9;
687 if (v->quantizer_mode == QUANT_NON_UNIFORM)
689 v->pqindex = pqindex;
691 v->halfpq = get_bits1(gb);
694 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
695 v->pquantizer = get_bits1(gb);
697 if (v->extended_mv == 1)
698 v->mvrange = get_unary(gb, 0, 3);
699 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
700 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
701 v->range_x = 1 << (v->k_x - 1);
702 v->range_y = 1 << (v->k_y - 1);
703 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
704 v->respic = get_bits(gb, 2);
706 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
707 v->x8_type = get_bits1(gb);
710 av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
711 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
712 pqindex, v->pq, v->halfpq, v->rangeredfrm);
714 if(v->first_pic_header_flag) {
718 switch (v->s.pict_type) {
719 case AV_PICTURE_TYPE_P:
720 if (v->pq < 5) v->tt_index = 0;
721 else if (v->pq < 13) v->tt_index = 1;
722 else v->tt_index = 2;
724 lowquant = (v->pq > 12) ? 0 : 1;
725 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
726 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
727 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
728 v->lumscale = get_bits(gb, 6);
729 v->lumshift = get_bits(gb, 6);
731 /* fill lookup tables for intensity compensation */
732 INIT_LUT(v->lumscale, v->lumshift , v->last_luty[0] , v->last_lutuv[0] , 1);
733 INIT_LUT(v->lumscale, v->lumshift , v->last_luty[1] , v->last_lutuv[1] , 1);
735 v->qs_last = v->s.quarter_sample;
736 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
737 v->s.quarter_sample = 0;
738 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
739 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
740 v->s.quarter_sample = 0;
742 v->s.quarter_sample = 1;
744 v->s.quarter_sample = 1;
745 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
747 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
748 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
749 v->mv_mode == MV_PMODE_MIXED_MV) {
750 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
753 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
754 "Imode: %i, Invert: %i\n", status>>1, status&1);
756 v->mv_type_is_raw = 0;
757 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
759 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
762 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
763 "Imode: %i, Invert: %i\n", status>>1, status&1);
765 /* Hopefully this is correct for P frames */
766 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
767 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
770 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
771 vop_dquant_decoding(v);
774 v->ttfrm = 0; //FIXME Is that so ?
775 if (v->vstransform) {
776 v->ttmbf = get_bits1(gb);
778 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
785 case AV_PICTURE_TYPE_B:
786 if (v->pq < 5) v->tt_index = 0;
787 else if (v->pq < 13) v->tt_index = 1;
788 else v->tt_index = 2;
790 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
791 v->qs_last = v->s.quarter_sample;
792 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
793 v->s.mspel = v->s.quarter_sample;
795 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
798 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
799 "Imode: %i, Invert: %i\n", status>>1, status&1);
800 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
803 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
804 "Imode: %i, Invert: %i\n", status>>1, status&1);
806 v->s.mv_table_index = get_bits(gb, 2);
807 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
810 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
811 vop_dquant_decoding(v);
815 if (v->vstransform) {
816 v->ttmbf = get_bits1(gb);
818 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
829 v->c_ac_table_index = decode012(gb);
830 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
831 v->y_ac_table_index = decode012(gb);
834 v->s.dc_table_index = get_bits1(gb);
837 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
838 v->s.pict_type = AV_PICTURE_TYPE_B;
844 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
846 int pqindex, lowquant;
848 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
852 v->p_frame_skipped = 0;
853 if (v->second_field) {
854 if(v->fcm!=2 || v->field_mode!=1)
856 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
858 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
859 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
860 if (!v->pic_header_flag)
861 goto parse_common_info;
868 if (fcm == ILACE_FIELD)
874 if (!v->first_pic_header_flag && v->field_mode != field_mode)
876 v->field_mode = field_mode;
880 v->fptype = get_bits(gb, 3);
881 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
882 if (v->fptype & 4) // B-picture
883 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
885 switch (get_unary(gb, 0, 4)) {
887 v->s.pict_type = AV_PICTURE_TYPE_P;
890 v->s.pict_type = AV_PICTURE_TYPE_B;
893 v->s.pict_type = AV_PICTURE_TYPE_I;
896 v->s.pict_type = AV_PICTURE_TYPE_BI;
899 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
900 v->p_frame_skipped = 1;
907 if (!v->interlace || v->psf) {
908 v->rptfrm = get_bits(gb, 2);
910 v->tff = get_bits1(gb);
911 v->rff = get_bits1(gb);
916 if (v->panscanflag) {
917 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
920 if (v->p_frame_skipped) {
923 v->rnd = get_bits1(gb);
925 v->uvsamp = get_bits1(gb);
926 if(!ff_vc1_bfraction_vlc.table)
927 return 0; //parsing only, vlc tables havnt been allocated
929 if (!v->refdist_flag)
931 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
932 v->refdist = get_bits(gb, 2);
934 v->refdist += get_unary(gb, 0, 16);
936 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
937 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
938 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
939 v->frfd = (v->bfraction * v->refdist) >> 8;
940 v->brfd = v->refdist - v->frfd - 1;
944 goto parse_common_info;
946 if (v->fcm == PROGRESSIVE) {
948 v->interpfrm = get_bits1(gb);
949 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
950 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
951 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
952 if (v->bfraction == 0) {
953 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
960 v->cur_field_type = !(v->tff ^ v->second_field);
961 pqindex = get_bits(gb, 5);
964 v->pqindex = pqindex;
965 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
966 v->pq = ff_vc1_pquant_table[0][pqindex];
968 v->pq = ff_vc1_pquant_table[1][pqindex];
971 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
972 v->pquantizer = pqindex < 9;
973 if (v->quantizer_mode == QUANT_NON_UNIFORM)
975 v->pqindex = pqindex;
977 v->halfpq = get_bits1(gb);
980 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
981 v->pquantizer = get_bits1(gb);
983 v->postproc = get_bits(gb, 2);
988 if(v->first_pic_header_flag) {
992 switch (v->s.pict_type) {
993 case AV_PICTURE_TYPE_I:
994 case AV_PICTURE_TYPE_BI:
995 if (v->fcm == ILACE_FRAME) { //interlace frame picture
996 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
999 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1000 "Imode: %i, Invert: %i\n", status>>1, status&1);
1002 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1005 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1006 "Imode: %i, Invert: %i\n", status>>1, status&1);
1007 v->condover = CONDOVER_NONE;
1008 if (v->overlap && v->pq <= 8) {
1009 v->condover = decode012(gb);
1010 if (v->condover == CONDOVER_SELECT) {
1011 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1014 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1015 "Imode: %i, Invert: %i\n", status>>1, status&1);
1019 case AV_PICTURE_TYPE_P:
1020 if (v->field_mode) {
1021 v->numref = get_bits1(gb);
1023 v->reffield = get_bits1(gb);
1024 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1028 v->mvrange = get_unary(gb, 0, 3);
1032 if (v->extended_dmv)
1033 v->dmvrange = get_unary(gb, 0, 3);
1036 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1037 v->fourmvswitch = get_bits1(gb);
1038 v->intcomp = get_bits1(gb);
1040 v->lumscale = get_bits(gb, 6);
1041 v->lumshift = get_bits(gb, 6);
1042 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1043 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1046 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1047 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1048 "Imode: %i, Invert: %i\n", status>>1, status&1);
1049 mbmodetab = get_bits(gb, 2);
1050 if (v->fourmvswitch)
1051 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1053 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1054 imvtab = get_bits(gb, 2);
1055 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1056 // interlaced p-picture cbpcy range is [1, 63]
1057 icbptab = get_bits(gb, 3);
1058 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1059 twomvbptab = get_bits(gb, 2);
1060 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1061 if (v->fourmvswitch) {
1062 fourmvbptab = get_bits(gb, 2);
1063 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1067 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1068 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1069 v->range_x = 1 << (v->k_x - 1);
1070 v->range_y = 1 << (v->k_y - 1);
1074 else if (v->pq < 13)
1078 if (v->fcm != ILACE_FRAME) {
1080 mvmode = get_unary(gb, 1, 4);
1081 lowquant = (v->pq > 12) ? 0 : 1;
1082 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1083 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1085 mvmode2 = get_unary(gb, 1, 3);
1086 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1087 if (v->field_mode) {
1088 v->intcompfield = decode210(gb)^3;
1090 v->intcompfield = 3;
1092 v->lumscale2 = v->lumscale = 32;
1093 v->lumshift2 = v->lumshift = 0;
1094 if (v->intcompfield & 1) {
1095 v->lumscale = get_bits(gb, 6);
1096 v->lumshift = get_bits(gb, 6);
1098 if ((v->intcompfield & 2) && v->field_mode) {
1099 v->lumscale2 = get_bits(gb, 6);
1100 v->lumshift2 = get_bits(gb, 6);
1101 } else if(!v->field_mode) {
1102 v->lumscale2 = v->lumscale;
1103 v->lumshift2 = v->lumshift;
1105 if (v->field_mode && v->second_field) {
1106 if (v->cur_field_type) {
1107 INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1108 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1110 INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1111 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1113 v->next_use_ic = v->curr_use_ic = 1;
1115 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1116 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1120 v->qs_last = v->s.quarter_sample;
1121 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1122 v->s.quarter_sample = 0;
1123 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1124 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1125 v->s.quarter_sample = 0;
1127 v->s.quarter_sample = 1;
1129 v->s.quarter_sample = 1;
1130 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1131 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1132 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1134 if (v->fcm == PROGRESSIVE) { // progressive
1135 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1136 v->mv_mode2 == MV_PMODE_MIXED_MV)
1137 || v->mv_mode == MV_PMODE_MIXED_MV) {
1138 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1141 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1142 "Imode: %i, Invert: %i\n", status>>1, status&1);
1144 v->mv_type_is_raw = 0;
1145 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1147 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1150 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1151 "Imode: %i, Invert: %i\n", status>>1, status&1);
1153 /* Hopefully this is correct for P frames */
1154 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1155 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1156 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1157 v->qs_last = v->s.quarter_sample;
1158 v->s.quarter_sample = 1;
1160 } else { // field interlaced
1161 mbmodetab = get_bits(gb, 3);
1162 imvtab = get_bits(gb, 2 + v->numref);
1164 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1166 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1167 icbptab = get_bits(gb, 3);
1168 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1169 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1170 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1171 fourmvbptab = get_bits(gb, 2);
1172 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1173 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1175 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1179 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1180 vop_dquant_decoding(v);
1183 v->ttfrm = 0; //FIXME Is that so ?
1184 if (v->vstransform) {
1185 v->ttmbf = get_bits1(gb);
1187 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1194 case AV_PICTURE_TYPE_B:
1195 if (v->fcm == ILACE_FRAME) {
1196 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1197 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1198 if (v->bfraction == 0) {
1203 v->mvrange = get_unary(gb, 0, 3);
1206 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1207 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1208 v->range_x = 1 << (v->k_x - 1);
1209 v->range_y = 1 << (v->k_y - 1);
1213 else if (v->pq < 13)
1218 if (v->field_mode) {
1220 av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1221 if (v->extended_dmv)
1222 v->dmvrange = get_unary(gb, 0, 3);
1223 mvmode = get_unary(gb, 1, 3);
1224 lowquant = (v->pq > 12) ? 0 : 1;
1225 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1226 v->qs_last = v->s.quarter_sample;
1227 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1228 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1229 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1232 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1233 "Imode: %i, Invert: %i\n", status>>1, status&1);
1234 mbmodetab = get_bits(gb, 3);
1235 if (v->mv_mode == MV_PMODE_MIXED_MV)
1236 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1238 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1239 imvtab = get_bits(gb, 3);
1240 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1241 icbptab = get_bits(gb, 3);
1242 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1243 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1244 fourmvbptab = get_bits(gb, 2);
1245 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1247 v->numref = 1; // interlaced field B pictures are always 2-ref
1248 } else if (v->fcm == ILACE_FRAME) {
1249 if (v->extended_dmv)
1250 v->dmvrange = get_unary(gb, 0, 3);
1251 get_bits1(gb); /* intcomp - present but shall always be 0 */
1253 v->mv_mode = MV_PMODE_1MV;
1254 v->fourmvswitch = 0;
1255 v->qs_last = v->s.quarter_sample;
1256 v->s.quarter_sample = 1;
1258 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1261 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1262 "Imode: %i, Invert: %i\n", status>>1, status&1);
1263 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1266 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1267 "Imode: %i, Invert: %i\n", status>>1, status&1);
1268 mbmodetab = get_bits(gb, 2);
1269 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1270 imvtab = get_bits(gb, 2);
1271 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1272 // interlaced p/b-picture cbpcy range is [1, 63]
1273 icbptab = get_bits(gb, 3);
1274 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1275 twomvbptab = get_bits(gb, 2);
1276 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1277 fourmvbptab = get_bits(gb, 2);
1278 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1280 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1281 v->qs_last = v->s.quarter_sample;
1282 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1283 v->s.mspel = v->s.quarter_sample;
1284 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1287 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1288 "Imode: %i, Invert: %i\n", status>>1, status&1);
1289 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1292 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1293 "Imode: %i, Invert: %i\n", status>>1, status&1);
1294 v->s.mv_table_index = get_bits(gb, 2);
1295 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1299 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1300 vop_dquant_decoding(v);
1304 if (v->vstransform) {
1305 v->ttmbf = get_bits1(gb);
1307 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1316 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1322 v->c_ac_table_index = decode012(gb);
1323 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1324 v->y_ac_table_index = decode012(gb);
1327 v->s.dc_table_index = get_bits1(gb);
1328 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1330 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1331 vop_dquant_decoding(v);
1335 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1336 v->s.pict_type = AV_PICTURE_TYPE_B;
1342 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1344 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1345 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1346 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1347 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1348 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1349 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1350 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1351 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1352 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1353 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1354 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1355 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1356 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1357 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1358 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1359 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1360 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1361 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1362 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1363 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1364 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1365 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1366 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1367 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1368 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1369 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1370 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1371 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1372 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1373 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1374 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1377 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1378 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1379 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1380 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1381 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1382 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1383 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1384 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1385 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1386 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1387 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1388 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1389 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1390 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1391 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1392 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1393 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1394 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1395 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1396 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1397 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1398 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1399 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1400 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1401 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1402 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1403 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1404 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1408 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1409 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1410 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1411 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1412 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1413 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1414 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1415 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1416 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1417 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1418 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1419 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1420 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1421 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1422 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1423 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1424 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1425 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1426 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1427 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1428 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1429 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1433 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1434 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1435 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1436 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1437 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1438 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1439 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1440 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1441 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1442 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1443 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1444 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1445 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1446 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1447 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1448 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1449 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1450 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1451 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1452 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1453 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1454 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1455 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1456 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1457 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1460 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1461 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1462 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1463 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1464 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1465 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1466 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1467 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1468 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1469 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1470 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1471 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1472 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1473 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1474 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1475 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1476 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1480 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1481 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1482 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1483 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1484 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1485 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1486 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1487 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1488 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1489 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1490 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1491 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1492 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1493 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1494 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1495 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1496 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1500 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1501 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1502 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1503 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1504 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1505 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1506 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1507 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1508 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1509 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1510 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1511 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1512 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1513 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1514 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1515 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1516 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1517 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1518 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1519 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1520 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1521 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1522 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1523 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1524 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1525 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1526 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1530 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1531 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1532 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1533 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1534 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1535 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1536 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1537 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1538 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1539 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1540 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1541 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1542 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1543 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1544 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1545 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1546 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1547 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1548 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1549 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1550 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1551 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1552 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1553 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1554 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1555 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1556 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1557 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1558 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1563 static const uint16_t vlc_offs[] = {
1564 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1565 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1566 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1567 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1568 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1569 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1570 31714, 31746, 31778, 32306, 32340, 32372
1574 * Init VC-1 specific tables and VC1Context members
1575 * @param v The VC1Context to initialize
1578 int ff_vc1_init_common(VC1Context *v)
1580 static int done = 0;
1582 static VLC_TYPE vlc_table[32372][2];
1584 v->hrd_rate = v->hrd_buffer = NULL;
1588 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1589 ff_vc1_bfraction_bits, 1, 1,
1590 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1591 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1592 ff_vc1_norm2_bits, 1, 1,
1593 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1594 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1595 ff_vc1_norm6_bits, 1, 1,
1596 ff_vc1_norm6_codes, 2, 2, 556);
1597 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1598 ff_vc1_imode_bits, 1, 1,
1599 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1600 for (i = 0; i < 3; i++) {
1601 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1602 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1603 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1604 ff_vc1_ttmb_bits[i], 1, 1,
1605 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1606 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1607 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1608 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1609 ff_vc1_ttblk_bits[i], 1, 1,
1610 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1611 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1612 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1613 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1614 ff_vc1_subblkpat_bits[i], 1, 1,
1615 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1617 for (i = 0; i < 4; i++) {
1618 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1619 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1620 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1621 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1622 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1623 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1624 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1625 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1626 ff_vc1_cbpcy_p_bits[i], 1, 1,
1627 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1628 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1629 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1630 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1631 ff_vc1_mv_diff_bits[i], 1, 1,
1632 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1634 for (i = 0; i < 8; i++) {
1635 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1636 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1637 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1638 &vc1_ac_tables[i][0][1], 8, 4,
1639 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1640 /* initialize interlaced MVDATA tables (2-Ref) */
1641 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1642 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1643 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1644 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1645 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1647 for (i = 0; i < 4; i++) {
1648 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1649 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1650 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1651 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1652 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1653 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1654 /* initialize NON-4MV MBMODE VLC tables for the same */
1655 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1656 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1657 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1658 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1659 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1660 /* initialize interlaced MVDATA tables (1-Ref) */
1661 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1662 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1663 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1664 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1665 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1667 for (i = 0; i < 4; i++) {
1668 /* Initialize 2MV Block pattern VLC tables */
1669 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1670 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1671 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1672 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1673 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1675 for (i = 0; i < 8; i++) {
1676 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1677 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1678 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1679 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1680 ff_vc1_icbpcy_p_bits[i], 1, 1,
1681 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1682 /* Initialize interlaced field picture MBMODE VLC tables */
1683 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1684 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1685 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1686 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1687 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1688 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1689 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1690 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1691 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1692 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1697 /* Other defaults */
1699 v->mvrange = 0; /* 7.1.1.18, p80 */