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
30 #include "libavutil/attributes.h"
33 #include "mpegvideo.h"
36 #include "msmpeg4data.h"
38 #include "simple_idct.h"
43 /***********************************************************************/
45 * @name VC-1 Bitplane decoding
50 /** Decode rows by checking if they are skipped
51 * @param plane Buffer to store decoded bits
52 * @param[in] width Width of this buffer
53 * @param[in] height Height of this buffer
54 * @param[in] stride of this buffer
56 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
61 for (y = 0; y < height; y++) {
62 if (!get_bits1(gb)) //rowskip
63 memset(plane, 0, width);
65 for (x = 0; x < width; x++)
66 plane[x] = get_bits1(gb);
71 /** Decode columns by checking if they are skipped
72 * @param plane Buffer to store decoded bits
73 * @param[in] width Width of this buffer
74 * @param[in] height Height of this buffer
75 * @param[in] stride of this buffer
76 * @todo FIXME: Optimize
78 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
83 for (x = 0; x < width; x++) {
84 if (!get_bits1(gb)) //colskip
85 for (y = 0; y < height; y++)
88 for (y = 0; y < height; y++)
89 plane[y*stride] = get_bits1(gb);
94 /** Decode a bitplane's bits
95 * @param data bitplane where to store the decode bits
96 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
97 * @param v VC-1 context for bit reading and logging
99 * @todo FIXME: Optimize
101 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
103 GetBitContext *gb = &v->s.gb;
105 int imode, x, y, code, offset;
106 uint8_t invert, *planep = data;
107 int width, height, stride;
109 width = v->s.mb_width;
110 height = v->s.mb_height >> v->field_mode;
111 stride = v->s.mb_stride;
112 invert = get_bits1(gb);
113 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
118 //Data is actually read in the MB layer (same for all tests == "raw")
119 *raw_flag = 1; //invert ignored
123 if ((height * width) & 1) {
124 *planep++ = get_bits1(gb);
126 if (offset == width) {
128 planep += stride - width;
133 // decode bitplane as one long line
134 for (; y < height * width; y += 2) {
135 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
136 *planep++ = code & 1;
138 if (offset == width) {
140 planep += stride - width;
142 *planep++ = code >> 1;
144 if (offset == width) {
146 planep += stride - width;
152 if (!(height % 3) && (width % 3)) { // use 2x3 decoding
153 for (y = 0; y < height; y += 3) {
154 for (x = width & 1; x < width; x += 2) {
155 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
157 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
160 planep[x + 0] = (code >> 0) & 1;
161 planep[x + 1] = (code >> 1) & 1;
162 planep[x + 0 + stride] = (code >> 2) & 1;
163 planep[x + 1 + stride] = (code >> 3) & 1;
164 planep[x + 0 + stride * 2] = (code >> 4) & 1;
165 planep[x + 1 + stride * 2] = (code >> 5) & 1;
167 planep += stride * 3;
170 decode_colskip(data, 1, height, stride, &v->s.gb);
172 planep += (height & 1) * stride;
173 for (y = height & 1; y < height; y += 2) {
174 for (x = width % 3; x < width; x += 3) {
175 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
177 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
180 planep[x + 0] = (code >> 0) & 1;
181 planep[x + 1] = (code >> 1) & 1;
182 planep[x + 2] = (code >> 2) & 1;
183 planep[x + 0 + stride] = (code >> 3) & 1;
184 planep[x + 1 + stride] = (code >> 4) & 1;
185 planep[x + 2 + stride] = (code >> 5) & 1;
187 planep += stride * 2;
191 decode_colskip(data, x, height, stride, &v->s.gb);
193 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
197 decode_rowskip(data, width, height, stride, &v->s.gb);
200 decode_colskip(data, width, height, stride, &v->s.gb);
206 /* Applying diff operator */
207 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
210 for (x = 1; x < width; x++)
211 planep[x] ^= planep[x-1];
212 for (y = 1; y < height; y++) {
214 planep[0] ^= planep[-stride];
215 for (x = 1; x < width; x++) {
216 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
217 else planep[x] ^= planep[x-1];
222 for (x = 0; x < stride * height; x++)
223 planep[x] = !planep[x]; //FIXME stride
225 return (imode << 1) + invert;
228 /** @} */ //Bitplane group
230 /***********************************************************************/
231 /** VOP Dquant decoding
232 * @param v VC-1 Context
234 static int vop_dquant_decoding(VC1Context *v)
236 GetBitContext *gb = &v->s.gb;
240 if (v->dquant == 2) {
241 pqdiff = get_bits(gb, 3);
243 v->altpq = get_bits(gb, 5);
245 v->altpq = v->pq + pqdiff + 1;
247 v->dquantfrm = get_bits1(gb);
249 v->dqprofile = get_bits(gb, 2);
250 switch (v->dqprofile) {
251 case DQPROFILE_SINGLE_EDGE:
252 case DQPROFILE_DOUBLE_EDGES:
253 v->dqsbedge = get_bits(gb, 2);
255 case DQPROFILE_ALL_MBS:
256 v->dqbilevel = get_bits1(gb);
262 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
263 pqdiff = get_bits(gb, 3);
265 v->altpq = get_bits(gb, 5);
267 v->altpq = v->pq + pqdiff + 1;
274 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
277 * Decode Simple/Main Profiles sequence header
278 * @see Figure 7-8, p16-17
279 * @param avctx Codec context
280 * @param gb GetBit context initialized from Codec context extra_data
283 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
285 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
286 v->profile = get_bits(gb, 2);
287 if (v->profile == PROFILE_COMPLEX) {
288 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
291 if (v->profile == PROFILE_ADVANCED) {
292 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
293 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
294 return decode_sequence_header_adv(v, gb);
297 v->zz_8x4 = ff_wmv2_scantableA;
298 v->zz_4x8 = ff_wmv2_scantableB;
299 v->res_y411 = get_bits1(gb);
300 v->res_sprite = get_bits1(gb);
302 av_log(avctx, AV_LOG_ERROR,
303 "Old interlaced mode is not supported\n");
309 v->frmrtq_postproc = get_bits(gb, 3); //common
310 // (bitrate-32kbps)/64kbps
311 v->bitrtq_postproc = get_bits(gb, 5); //common
312 v->s.loop_filter = get_bits1(gb); //common
313 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
314 av_log(avctx, AV_LOG_ERROR,
315 "LOOPFILTER shall not be enabled in Simple Profile\n");
317 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
318 v->s.loop_filter = 0;
320 v->res_x8 = get_bits1(gb); //reserved
321 v->multires = get_bits1(gb);
322 v->res_fasttx = get_bits1(gb);
323 if (!v->res_fasttx) {
324 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;
325 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
326 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
327 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
328 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
329 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
330 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
331 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
334 v->fastuvmc = get_bits1(gb); //common
335 if (!v->profile && !v->fastuvmc) {
336 av_log(avctx, AV_LOG_ERROR,
337 "FASTUVMC unavailable in Simple Profile\n");
340 v->extended_mv = get_bits1(gb); //common
341 if (!v->profile && v->extended_mv)
343 av_log(avctx, AV_LOG_ERROR,
344 "Extended MVs unavailable in Simple Profile\n");
347 v->dquant = get_bits(gb, 2); //common
348 v->vstransform = get_bits1(gb); //common
350 v->res_transtab = get_bits1(gb);
353 av_log(avctx, AV_LOG_ERROR,
354 "1 for reserved RES_TRANSTAB is forbidden\n");
358 v->overlap = get_bits1(gb); //common
360 v->resync_marker = get_bits1(gb);
361 v->rangered = get_bits1(gb);
362 if (v->rangered && v->profile == PROFILE_SIMPLE) {
363 av_log(avctx, AV_LOG_INFO,
364 "RANGERED should be set to 0 in Simple Profile\n");
367 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
368 v->quantizer_mode = get_bits(gb, 2); //common
370 v->finterpflag = get_bits1(gb); //common
373 int w = get_bits(gb, 11);
374 int h = get_bits(gb, 11);
375 avcodec_set_dimensions(v->s.avctx, w, h);
376 skip_bits(gb, 5); //frame rate
377 v->res_x8 = get_bits1(gb);
378 if (get_bits1(gb)) { // something to do with DC VLC selection
379 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
382 skip_bits(gb, 3); //slice code
385 v->res_rtm_flag = get_bits1(gb); //reserved
387 if (!v->res_rtm_flag) {
388 av_log(avctx, AV_LOG_ERROR,
389 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
392 //TODO: figure out what they mean (always 0x402F)
395 av_log(avctx, AV_LOG_DEBUG,
396 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
397 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
398 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
399 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
400 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
401 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
402 v->rangered, v->vstransform, v->overlap, v->resync_marker,
403 v->dquant, v->quantizer_mode, avctx->max_b_frames);
407 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
410 v->level = get_bits(gb, 3);
412 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
414 v->chromaformat = get_bits(gb, 2);
415 if (v->chromaformat != 1) {
416 av_log(v->s.avctx, AV_LOG_ERROR,
417 "Only 4:2:0 chroma format supported\n");
422 v->frmrtq_postproc = get_bits(gb, 3); //common
423 // (bitrate-32kbps)/64kbps
424 v->bitrtq_postproc = get_bits(gb, 5); //common
425 v->postprocflag = get_bits1(gb); //common
427 v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
428 v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
429 v->broadcast = get_bits1(gb);
430 v->interlace = get_bits1(gb);
431 v->tfcntrflag = get_bits1(gb);
432 v->finterpflag = get_bits1(gb);
433 skip_bits1(gb); // reserved
435 av_log(v->s.avctx, AV_LOG_DEBUG,
436 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
437 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
438 "TFCTRflag=%i, FINTERPflag=%i\n",
439 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
440 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
441 v->tfcntrflag, v->finterpflag);
443 v->psf = get_bits1(gb);
444 if (v->psf) { //PsF, 6.1.13
445 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
448 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
449 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
451 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
452 w = get_bits(gb, 14) + 1;
453 h = get_bits(gb, 14) + 1;
454 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
456 ar = get_bits(gb, 4);
458 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
459 } else if (ar == 15) {
460 w = get_bits(gb, 8) + 1;
461 h = get_bits(gb, 8) + 1;
462 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
464 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
465 &v->s.avctx->sample_aspect_ratio.den,
466 v->s.avctx->height * w,
467 v->s.avctx->width * h,
470 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
471 v->s.avctx->sample_aspect_ratio.num,
472 v->s.avctx->sample_aspect_ratio.den);
474 if (get_bits1(gb)) { //framerate stuff
476 v->s.avctx->time_base.num = 32;
477 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
480 nr = get_bits(gb, 8);
481 dr = get_bits(gb, 4);
482 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
483 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
484 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
487 if (v->broadcast) { // Pulldown may be present
488 v->s.avctx->time_base.den *= 2;
489 v->s.avctx->ticks_per_frame = 2;
494 v->s.avctx->color_primaries = get_bits(gb, 8);
495 v->s.avctx->color_trc = get_bits(gb, 8);
496 v->s.avctx->colorspace = get_bits(gb, 8);
497 v->s.avctx->color_range = AVCOL_RANGE_MPEG;
501 v->hrd_param_flag = get_bits1(gb);
502 if (v->hrd_param_flag) {
504 v->hrd_num_leaky_buckets = get_bits(gb, 5);
505 skip_bits(gb, 4); //bitrate exponent
506 skip_bits(gb, 4); //buffer size exponent
507 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
508 skip_bits(gb, 16); //hrd_rate[n]
509 skip_bits(gb, 16); //hrd_buffer[n]
515 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
520 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
521 v->broken_link = get_bits1(gb);
522 v->closed_entry = get_bits1(gb);
523 v->panscanflag = get_bits1(gb);
524 v->refdist_flag = get_bits1(gb);
525 v->s.loop_filter = get_bits1(gb);
526 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
527 v->s.loop_filter = 0;
528 v->fastuvmc = get_bits1(gb);
529 v->extended_mv = get_bits1(gb);
530 v->dquant = get_bits(gb, 2);
531 v->vstransform = get_bits1(gb);
532 v->overlap = get_bits1(gb);
533 v->quantizer_mode = get_bits(gb, 2);
535 if (v->hrd_param_flag) {
536 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
537 skip_bits(gb, 8); //hrd_full[n]
542 w = (get_bits(gb, 12)+1)<<1;
543 h = (get_bits(gb, 12)+1)<<1;
545 w = v->max_coded_width;
546 h = v->max_coded_height;
548 avcodec_set_dimensions(avctx, w, h);
550 v->extended_dmv = get_bits1(gb);
551 if ((v->range_mapy_flag = get_bits1(gb))) {
552 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
553 v->range_mapy = get_bits(gb, 3);
555 if ((v->range_mapuv_flag = get_bits1(gb))) {
556 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
557 v->range_mapuv = get_bits(gb, 3);
560 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
561 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
562 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
563 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
564 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
565 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
570 /* fill lookup tables for intensity compensation */
571 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \
572 int scale, shift, i; \
575 shift = (255 - lumshift * 2) << 6; \
579 scale = lumscale + 32; \
581 shift = (lumshift - 64) << 6; \
583 shift = lumshift << 6; \
585 for (i = 0; i < 256; i++) { \
586 int iy = chain ? luty[i] : i; \
587 int iu = chain ? lutuv[i] : i; \
588 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
589 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
593 static void rotate_luts(VC1Context *v)
595 #define ROTATE(DEF, L, N, C, A) do { \
596 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
600 memcpy(&tmp, L , sizeof(tmp)); \
601 memcpy(L , N , sizeof(tmp)); \
602 memcpy(N , &tmp, sizeof(tmp)); \
607 ROTATE(int *tmp, &v->last_use_ic, &v->next_use_ic, v->curr_use_ic, &v->aux_use_ic);
608 ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
609 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
611 INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
612 INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
616 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
618 int pqindex, lowquant, status;
621 v->interpfrm = get_bits1(gb);
622 if (!v->s.avctx->codec)
624 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
627 v->multires = get_bits(gb, 2) == 1;
629 skip_bits(gb, 2); //framecnt unused
632 v->rangeredfrm = get_bits1(gb);
633 v->s.pict_type = get_bits1(gb);
634 if (v->s.avctx->max_b_frames) {
635 if (!v->s.pict_type) {
637 v->s.pict_type = AV_PICTURE_TYPE_I;
639 v->s.pict_type = AV_PICTURE_TYPE_B;
641 v->s.pict_type = AV_PICTURE_TYPE_P;
643 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
646 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
647 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
648 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
649 if (v->bfraction == 0) {
650 v->s.pict_type = AV_PICTURE_TYPE_BI;
653 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
654 skip_bits(gb, 7); // skip buffer fullness
660 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
662 if (v->s.pict_type == AV_PICTURE_TYPE_P)
665 /* Quantizer stuff */
666 pqindex = get_bits(gb, 5);
669 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
670 v->pq = ff_vc1_pquant_table[0][pqindex];
672 v->pq = ff_vc1_pquant_table[1][pqindex];
675 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
676 v->pquantizer = pqindex < 9;
677 if (v->quantizer_mode == QUANT_NON_UNIFORM)
679 v->pqindex = pqindex;
681 v->halfpq = get_bits1(gb);
684 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
685 v->pquantizer = get_bits1(gb);
687 if (v->extended_mv == 1)
688 v->mvrange = get_unary(gb, 0, 3);
689 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
690 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
691 v->range_x = 1 << (v->k_x - 1);
692 v->range_y = 1 << (v->k_y - 1);
693 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
694 v->respic = get_bits(gb, 2);
696 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
697 v->x8_type = get_bits1(gb);
700 av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
701 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
702 pqindex, v->pq, v->halfpq, v->rangeredfrm);
704 if (v->first_pic_header_flag)
707 switch (v->s.pict_type) {
708 case AV_PICTURE_TYPE_P:
709 if (v->pq < 5) v->tt_index = 0;
710 else if (v->pq < 13) v->tt_index = 1;
711 else v->tt_index = 2;
713 lowquant = (v->pq > 12) ? 0 : 1;
714 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
715 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
716 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
717 v->lumscale = get_bits(gb, 6);
718 v->lumshift = get_bits(gb, 6);
720 /* fill lookup tables for intensity compensation */
721 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
722 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
724 v->qs_last = v->s.quarter_sample;
725 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
726 v->s.quarter_sample = 0;
727 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
728 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
729 v->s.quarter_sample = 0;
731 v->s.quarter_sample = 1;
733 v->s.quarter_sample = 1;
734 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));
736 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
737 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
738 v->mv_mode == MV_PMODE_MIXED_MV) {
739 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
742 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
743 "Imode: %i, Invert: %i\n", status>>1, status&1);
745 v->mv_type_is_raw = 0;
746 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
748 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
751 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
752 "Imode: %i, Invert: %i\n", status>>1, status&1);
754 /* Hopefully this is correct for P frames */
755 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
756 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
759 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
760 vop_dquant_decoding(v);
763 v->ttfrm = 0; //FIXME Is that so ?
764 if (v->vstransform) {
765 v->ttmbf = get_bits1(gb);
767 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
774 case AV_PICTURE_TYPE_B:
775 if (v->pq < 5) v->tt_index = 0;
776 else if (v->pq < 13) v->tt_index = 1;
777 else v->tt_index = 2;
779 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
780 v->qs_last = v->s.quarter_sample;
781 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
782 v->s.mspel = v->s.quarter_sample;
784 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
787 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
788 "Imode: %i, Invert: %i\n", status>>1, status&1);
789 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
792 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
793 "Imode: %i, Invert: %i\n", status>>1, status&1);
795 v->s.mv_table_index = get_bits(gb, 2);
796 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
799 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
800 vop_dquant_decoding(v);
804 if (v->vstransform) {
805 v->ttmbf = get_bits1(gb);
807 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
818 v->c_ac_table_index = decode012(gb);
819 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
820 v->y_ac_table_index = decode012(gb);
823 v->s.dc_table_index = get_bits1(gb);
826 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
827 v->s.pict_type = AV_PICTURE_TYPE_B;
833 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
835 int pqindex, lowquant;
837 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
841 v->p_frame_skipped = 0;
842 if (v->second_field) {
843 if(v->fcm!=2 || v->field_mode!=1)
845 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
847 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
848 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
849 if (!v->pic_header_flag)
850 goto parse_common_info;
857 if (fcm == ILACE_FIELD)
863 if (!v->first_pic_header_flag && v->field_mode != field_mode)
864 return AVERROR_INVALIDDATA;
865 v->field_mode = field_mode;
868 av_assert0( v->s.mb_height == v->s.height + 15 >> 4
869 || v->s.mb_height == FFALIGN(v->s.height + 15 >> 4, 2));
871 v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
872 v->fptype = get_bits(gb, 3);
873 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
874 if (v->fptype & 4) // B-picture
875 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
878 v->s.mb_height = v->s.height + 15 >> 4;
879 switch (get_unary(gb, 0, 4)) {
881 v->s.pict_type = AV_PICTURE_TYPE_P;
884 v->s.pict_type = AV_PICTURE_TYPE_B;
887 v->s.pict_type = AV_PICTURE_TYPE_I;
890 v->s.pict_type = AV_PICTURE_TYPE_BI;
893 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
894 v->p_frame_skipped = 1;
901 if (!v->interlace || v->psf) {
902 v->rptfrm = get_bits(gb, 2);
904 v->tff = get_bits1(gb);
905 v->rff = get_bits1(gb);
910 if (v->panscanflag) {
911 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
914 if (v->p_frame_skipped) {
917 v->rnd = get_bits1(gb);
919 v->uvsamp = get_bits1(gb);
920 if(!ff_vc1_bfraction_vlc.table)
921 return 0; //parsing only, vlc tables havnt been allocated
923 if (!v->refdist_flag)
925 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
926 v->refdist = get_bits(gb, 2);
928 v->refdist += get_unary(gb, 0, 16);
930 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
931 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
932 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
933 v->frfd = (v->bfraction * v->refdist) >> 8;
934 v->brfd = v->refdist - v->frfd - 1;
938 goto parse_common_info;
940 if (v->fcm == PROGRESSIVE) {
942 v->interpfrm = get_bits1(gb);
943 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
944 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
945 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
946 if (v->bfraction == 0) {
947 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
954 v->cur_field_type = !(v->tff ^ v->second_field);
955 pqindex = get_bits(gb, 5);
958 v->pqindex = pqindex;
959 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
960 v->pq = ff_vc1_pquant_table[0][pqindex];
962 v->pq = ff_vc1_pquant_table[1][pqindex];
965 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
966 v->pquantizer = pqindex < 9;
967 if (v->quantizer_mode == QUANT_NON_UNIFORM)
969 v->pqindex = pqindex;
971 v->halfpq = get_bits1(gb);
974 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
975 v->pquantizer = get_bits1(gb);
977 v->postproc = get_bits(gb, 2);
982 if (v->first_pic_header_flag)
985 switch (v->s.pict_type) {
986 case AV_PICTURE_TYPE_I:
987 case AV_PICTURE_TYPE_BI:
988 if (v->fcm == ILACE_FRAME) { //interlace frame picture
989 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
992 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
993 "Imode: %i, Invert: %i\n", status>>1, status&1);
995 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
998 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
999 "Imode: %i, Invert: %i\n", status>>1, status&1);
1000 v->condover = CONDOVER_NONE;
1001 if (v->overlap && v->pq <= 8) {
1002 v->condover = decode012(gb);
1003 if (v->condover == CONDOVER_SELECT) {
1004 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1007 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1008 "Imode: %i, Invert: %i\n", status>>1, status&1);
1012 case AV_PICTURE_TYPE_P:
1013 if (v->field_mode) {
1014 v->numref = get_bits1(gb);
1016 v->reffield = get_bits1(gb);
1017 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1023 v->mvrange = get_unary(gb, 0, 3);
1027 if (v->extended_dmv)
1028 v->dmvrange = get_unary(gb, 0, 3);
1031 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1032 v->fourmvswitch = get_bits1(gb);
1033 v->intcomp = get_bits1(gb);
1035 v->lumscale = get_bits(gb, 6);
1036 v->lumshift = get_bits(gb, 6);
1037 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1038 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1041 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1042 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1043 "Imode: %i, Invert: %i\n", status>>1, status&1);
1044 mbmodetab = get_bits(gb, 2);
1045 if (v->fourmvswitch)
1046 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1048 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1049 imvtab = get_bits(gb, 2);
1050 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1051 // interlaced p-picture cbpcy range is [1, 63]
1052 icbptab = get_bits(gb, 3);
1053 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1054 twomvbptab = get_bits(gb, 2);
1055 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1056 if (v->fourmvswitch) {
1057 fourmvbptab = get_bits(gb, 2);
1058 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1062 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1063 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1064 v->range_x = 1 << (v->k_x - 1);
1065 v->range_y = 1 << (v->k_y - 1);
1069 else if (v->pq < 13)
1073 if (v->fcm != ILACE_FRAME) {
1075 mvmode = get_unary(gb, 1, 4);
1076 lowquant = (v->pq > 12) ? 0 : 1;
1077 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1078 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1080 mvmode2 = get_unary(gb, 1, 3);
1081 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1082 if (v->field_mode) {
1083 v->intcompfield = decode210(gb) ^ 3;
1085 v->intcompfield = 3;
1087 v->lumscale2 = v->lumscale = 32;
1088 v->lumshift2 = v->lumshift = 0;
1089 if (v->intcompfield & 1) {
1090 v->lumscale = get_bits(gb, 6);
1091 v->lumshift = get_bits(gb, 6);
1093 if ((v->intcompfield & 2) && v->field_mode) {
1094 v->lumscale2 = get_bits(gb, 6);
1095 v->lumshift2 = get_bits(gb, 6);
1096 } else if(!v->field_mode) {
1097 v->lumscale2 = v->lumscale;
1098 v->lumshift2 = v->lumshift;
1100 if (v->field_mode && v->second_field) {
1101 if (v->cur_field_type) {
1102 INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1103 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1105 INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1106 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1108 v->next_use_ic = *v->curr_use_ic = 1;
1110 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1111 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1115 v->qs_last = v->s.quarter_sample;
1116 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1117 v->s.quarter_sample = 0;
1118 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1119 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1120 v->s.quarter_sample = 0;
1122 v->s.quarter_sample = 1;
1124 v->s.quarter_sample = 1;
1125 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1126 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1127 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1129 if (v->fcm == PROGRESSIVE) { // progressive
1130 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1131 v->mv_mode2 == MV_PMODE_MIXED_MV)
1132 || v->mv_mode == MV_PMODE_MIXED_MV) {
1133 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1136 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1137 "Imode: %i, Invert: %i\n", status>>1, status&1);
1139 v->mv_type_is_raw = 0;
1140 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1142 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1145 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1146 "Imode: %i, Invert: %i\n", status>>1, status&1);
1148 /* Hopefully this is correct for P frames */
1149 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1150 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1151 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1152 v->qs_last = v->s.quarter_sample;
1153 v->s.quarter_sample = 1;
1155 } else { // field interlaced
1156 mbmodetab = get_bits(gb, 3);
1157 imvtab = get_bits(gb, 2 + v->numref);
1159 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1161 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1162 icbptab = get_bits(gb, 3);
1163 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1164 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1165 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1166 fourmvbptab = get_bits(gb, 2);
1167 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1168 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1170 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1174 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1175 vop_dquant_decoding(v);
1178 v->ttfrm = 0; //FIXME Is that so ?
1179 if (v->vstransform) {
1180 v->ttmbf = get_bits1(gb);
1182 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1189 case AV_PICTURE_TYPE_B:
1190 if (v->fcm == ILACE_FRAME) {
1191 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1192 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1193 if (v->bfraction == 0) {
1198 v->mvrange = get_unary(gb, 0, 3);
1201 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1202 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1203 v->range_x = 1 << (v->k_x - 1);
1204 v->range_y = 1 << (v->k_y - 1);
1208 else if (v->pq < 13)
1213 if (v->field_mode) {
1215 av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1216 if (v->extended_dmv)
1217 v->dmvrange = get_unary(gb, 0, 3);
1218 mvmode = get_unary(gb, 1, 3);
1219 lowquant = (v->pq > 12) ? 0 : 1;
1220 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1221 v->qs_last = v->s.quarter_sample;
1222 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1223 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1224 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1227 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1228 "Imode: %i, Invert: %i\n", status>>1, status&1);
1229 mbmodetab = get_bits(gb, 3);
1230 if (v->mv_mode == MV_PMODE_MIXED_MV)
1231 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1233 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1234 imvtab = get_bits(gb, 3);
1235 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1236 icbptab = get_bits(gb, 3);
1237 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1238 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1239 fourmvbptab = get_bits(gb, 2);
1240 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1242 v->numref = 1; // interlaced field B pictures are always 2-ref
1243 } else if (v->fcm == ILACE_FRAME) {
1244 if (v->extended_dmv)
1245 v->dmvrange = get_unary(gb, 0, 3);
1246 if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1247 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1249 v->mv_mode = MV_PMODE_1MV;
1250 v->fourmvswitch = 0;
1251 v->qs_last = v->s.quarter_sample;
1252 v->s.quarter_sample = 1;
1254 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1257 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1258 "Imode: %i, Invert: %i\n", status>>1, status&1);
1259 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1262 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1263 "Imode: %i, Invert: %i\n", status>>1, status&1);
1264 mbmodetab = get_bits(gb, 2);
1265 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1266 imvtab = get_bits(gb, 2);
1267 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1268 // interlaced p/b-picture cbpcy range is [1, 63]
1269 icbptab = get_bits(gb, 3);
1270 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1271 twomvbptab = get_bits(gb, 2);
1272 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1273 fourmvbptab = get_bits(gb, 2);
1274 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1276 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1277 v->qs_last = v->s.quarter_sample;
1278 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1279 v->s.mspel = v->s.quarter_sample;
1280 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1283 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1284 "Imode: %i, Invert: %i\n", status>>1, status&1);
1285 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1288 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1289 "Imode: %i, Invert: %i\n", status>>1, status&1);
1290 v->s.mv_table_index = get_bits(gb, 2);
1291 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1295 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1296 vop_dquant_decoding(v);
1300 if (v->vstransform) {
1301 v->ttmbf = get_bits1(gb);
1303 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1312 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1318 v->c_ac_table_index = decode012(gb);
1319 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1320 v->y_ac_table_index = decode012(gb);
1323 v->s.dc_table_index = get_bits1(gb);
1324 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1326 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1327 vop_dquant_decoding(v);
1331 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1332 v->s.pict_type = AV_PICTURE_TYPE_B;
1338 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1340 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1341 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1342 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1343 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1344 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1345 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1346 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1347 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1348 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1349 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1350 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1351 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1352 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1353 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1354 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1355 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1356 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1357 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1358 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1359 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1360 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1361 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1362 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1363 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1364 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1365 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1366 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1367 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1368 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1369 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1370 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1373 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1374 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1375 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1376 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1377 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1378 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1379 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1380 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1381 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1382 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1383 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1384 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1385 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1386 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1387 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1388 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1389 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1390 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1391 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1392 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1393 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1394 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1395 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1396 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1397 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1398 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1399 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1400 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1404 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1405 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1406 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1407 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1408 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1409 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1410 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1411 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1412 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1413 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1414 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1415 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1416 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1417 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1418 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1419 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1420 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1421 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1422 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1423 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1424 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1425 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1429 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1430 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1431 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1432 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1433 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1434 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1435 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1436 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1437 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1438 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1439 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1440 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1441 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1442 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1443 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1444 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1445 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1446 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1447 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1448 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1449 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1450 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1451 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1452 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1453 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1456 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1457 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1458 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1459 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1460 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1461 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1462 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1463 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1464 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1465 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1466 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1467 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1468 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1469 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1470 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1471 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1472 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1476 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1477 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1478 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1479 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1480 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1481 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1482 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1483 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1484 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1485 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1486 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1487 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1488 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1489 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1490 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1491 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1492 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1496 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1497 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1498 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1499 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1500 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1501 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1502 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1503 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1504 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1505 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1506 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1507 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1508 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1509 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1510 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1511 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1512 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1513 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1514 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1515 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1516 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1517 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1518 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1519 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1520 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1521 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1522 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1526 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1527 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1528 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1529 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1530 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1531 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1532 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1533 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1534 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1535 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1536 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1537 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1538 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1539 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1540 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1541 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1542 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1543 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1544 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1545 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1546 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1547 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1548 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1549 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1550 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1551 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1552 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1553 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1554 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1559 static const uint16_t vlc_offs[] = {
1560 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1561 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1562 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1563 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1564 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1565 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1566 31714, 31746, 31778, 32306, 32340, 32372
1570 * Init VC-1 specific tables and VC1Context members
1571 * @param v The VC1Context to initialize
1574 av_cold int ff_vc1_init_common(VC1Context *v)
1576 static int done = 0;
1578 static VLC_TYPE vlc_table[32372][2];
1580 v->hrd_rate = v->hrd_buffer = NULL;
1584 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1585 ff_vc1_bfraction_bits, 1, 1,
1586 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1587 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1588 ff_vc1_norm2_bits, 1, 1,
1589 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1590 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1591 ff_vc1_norm6_bits, 1, 1,
1592 ff_vc1_norm6_codes, 2, 2, 556);
1593 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1594 ff_vc1_imode_bits, 1, 1,
1595 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1596 for (i = 0; i < 3; i++) {
1597 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1598 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1599 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1600 ff_vc1_ttmb_bits[i], 1, 1,
1601 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1602 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1603 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1604 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1605 ff_vc1_ttblk_bits[i], 1, 1,
1606 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1607 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1608 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1609 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1610 ff_vc1_subblkpat_bits[i], 1, 1,
1611 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1613 for (i = 0; i < 4; i++) {
1614 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1615 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1616 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1617 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1618 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1619 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1620 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1621 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1622 ff_vc1_cbpcy_p_bits[i], 1, 1,
1623 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1624 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1625 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1626 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1627 ff_vc1_mv_diff_bits[i], 1, 1,
1628 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1630 for (i = 0; i < 8; i++) {
1631 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1632 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1633 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1634 &vc1_ac_tables[i][0][1], 8, 4,
1635 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1636 /* initialize interlaced MVDATA tables (2-Ref) */
1637 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1638 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1639 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1640 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1641 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1643 for (i = 0; i < 4; i++) {
1644 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1645 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1646 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1647 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1648 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1649 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1650 /* initialize NON-4MV MBMODE VLC tables for the same */
1651 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1652 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1653 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1654 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1655 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1656 /* initialize interlaced MVDATA tables (1-Ref) */
1657 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1658 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1659 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1660 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1661 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1663 for (i = 0; i < 4; i++) {
1664 /* Initialize 2MV Block pattern VLC tables */
1665 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1666 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1667 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1668 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1669 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1671 for (i = 0; i < 8; i++) {
1672 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1673 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1674 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1675 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1676 ff_vc1_icbpcy_p_bits[i], 1, 1,
1677 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1678 /* Initialize interlaced field picture MBMODE VLC tables */
1679 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1680 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1681 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1682 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1683 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1684 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1685 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1686 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1687 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1688 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1693 /* Other defaults */
1695 v->mvrange = 0; /* 7.1.1.18, p80 */