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
33 #include "mpegvideo.h"
36 #include "msmpeg4data.h"
38 #include "simple_idct.h"
43 /***********************************************************************/
45 * @name VC-1 Bitplane decoding
63 /** @} */ //imode defines
65 /** Decode rows by checking if they are skipped
66 * @param plane Buffer to store decoded bits
67 * @param[in] width Width of this buffer
68 * @param[in] height Height of this buffer
69 * @param[in] stride of this buffer
71 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
76 for (y = 0; y < height; y++) {
77 if (!get_bits1(gb)) //rowskip
78 memset(plane, 0, width);
80 for (x = 0; x < width; x++)
81 plane[x] = get_bits1(gb);
86 /** Decode columns by checking if they are skipped
87 * @param plane Buffer to store decoded bits
88 * @param[in] width Width of this buffer
89 * @param[in] height Height of this buffer
90 * @param[in] stride of this buffer
91 * @todo FIXME: Optimize
93 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
98 for (x = 0; x < width; x++) {
99 if (!get_bits1(gb)) //colskip
100 for (y = 0; y < height; y++)
103 for (y = 0; y < height; y++)
104 plane[y*stride] = get_bits1(gb);
109 /** Decode a bitplane's bits
110 * @param data bitplane where to store the decode bits
111 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
112 * @param v VC-1 context for bit reading and logging
114 * @todo FIXME: Optimize
116 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
118 GetBitContext *gb = &v->s.gb;
120 int imode, x, y, code, offset;
121 uint8_t invert, *planep = data;
122 int width, height, stride;
124 width = v->s.mb_width;
125 height = v->s.mb_height >> v->field_mode;
126 stride = v->s.mb_stride;
127 invert = get_bits1(gb);
128 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
133 //Data is actually read in the MB layer (same for all tests == "raw")
134 *raw_flag = 1; //invert ignored
138 if ((height * width) & 1) {
139 *planep++ = get_bits1(gb);
144 // decode bitplane as one long line
145 for (y = offset; y < height * width; y += 2) {
146 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
147 *planep++ = code & 1;
149 if (offset == width) {
151 planep += stride - width;
153 *planep++ = code >> 1;
155 if (offset == width) {
157 planep += stride - width;
163 if (!(height % 3) && (width % 3)) { // use 2x3 decoding
164 for (y = 0; y < height; y += 3) {
165 for (x = width & 1; x < width; x += 2) {
166 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
168 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
171 planep[x + 0] = (code >> 0) & 1;
172 planep[x + 1] = (code >> 1) & 1;
173 planep[x + 0 + stride] = (code >> 2) & 1;
174 planep[x + 1 + stride] = (code >> 3) & 1;
175 planep[x + 0 + stride * 2] = (code >> 4) & 1;
176 planep[x + 1 + stride * 2] = (code >> 5) & 1;
178 planep += stride * 3;
181 decode_colskip(data, 1, height, stride, &v->s.gb);
183 planep += (height & 1) * stride;
184 for (y = height & 1; y < height; y += 2) {
185 for (x = width % 3; x < width; x += 3) {
186 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
188 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
191 planep[x + 0] = (code >> 0) & 1;
192 planep[x + 1] = (code >> 1) & 1;
193 planep[x + 2] = (code >> 2) & 1;
194 planep[x + 0 + stride] = (code >> 3) & 1;
195 planep[x + 1 + stride] = (code >> 4) & 1;
196 planep[x + 2 + stride] = (code >> 5) & 1;
198 planep += stride * 2;
202 decode_colskip(data, x, height, stride, &v->s.gb);
204 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
208 decode_rowskip(data, width, height, stride, &v->s.gb);
211 decode_colskip(data, width, height, stride, &v->s.gb);
217 /* Applying diff operator */
218 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
221 for (x = 1; x < width; x++)
222 planep[x] ^= planep[x-1];
223 for (y = 1; y < height; y++) {
225 planep[0] ^= planep[-stride];
226 for (x = 1; x < width; x++) {
227 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
228 else planep[x] ^= planep[x-1];
233 for (x = 0; x < stride * height; x++)
234 planep[x] = !planep[x]; //FIXME stride
236 return (imode << 1) + invert;
239 /** @} */ //Bitplane group
241 /***********************************************************************/
242 /** VOP Dquant decoding
243 * @param v VC-1 Context
245 static int vop_dquant_decoding(VC1Context *v)
247 GetBitContext *gb = &v->s.gb;
251 if (v->dquant == 2) {
252 pqdiff = get_bits(gb, 3);
254 v->altpq = get_bits(gb, 5);
256 v->altpq = v->pq + pqdiff + 1;
258 v->dquantfrm = get_bits1(gb);
260 v->dqprofile = get_bits(gb, 2);
261 switch (v->dqprofile) {
262 case DQPROFILE_SINGLE_EDGE:
263 case DQPROFILE_DOUBLE_EDGES:
264 v->dqsbedge = get_bits(gb, 2);
266 case DQPROFILE_ALL_MBS:
267 v->dqbilevel = get_bits1(gb);
273 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
274 pqdiff = get_bits(gb, 3);
276 v->altpq = get_bits(gb, 5);
278 v->altpq = v->pq + pqdiff + 1;
285 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
288 * Decode Simple/Main Profiles sequence header
289 * @see Figure 7-8, p16-17
290 * @param avctx Codec context
291 * @param gb GetBit context initialized from Codec context extra_data
294 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
296 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
297 v->profile = get_bits(gb, 2);
298 if (v->profile == PROFILE_COMPLEX) {
299 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
302 if (v->profile == PROFILE_ADVANCED) {
303 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
304 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
305 return decode_sequence_header_adv(v, gb);
307 v->zz_8x4 = ff_wmv2_scantableA;
308 v->zz_4x8 = ff_wmv2_scantableB;
309 v->res_y411 = get_bits1(gb);
310 v->res_sprite = get_bits1(gb);
312 av_log(avctx, AV_LOG_ERROR,
313 "Old interlaced mode is not supported\n");
319 v->frmrtq_postproc = get_bits(gb, 3); //common
320 // (bitrate-32kbps)/64kbps
321 v->bitrtq_postproc = get_bits(gb, 5); //common
322 v->s.loop_filter = get_bits1(gb); //common
323 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
324 av_log(avctx, AV_LOG_ERROR,
325 "LOOPFILTER shall not be enabled in Simple Profile\n");
327 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
328 v->s.loop_filter = 0;
330 v->res_x8 = get_bits1(gb); //reserved
331 v->multires = get_bits1(gb);
332 v->res_fasttx = get_bits1(gb);
333 if (!v->res_fasttx) {
334 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;
335 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
336 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
337 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
338 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
339 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
340 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
341 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
344 v->fastuvmc = get_bits1(gb); //common
345 if (!v->profile && !v->fastuvmc) {
346 av_log(avctx, AV_LOG_ERROR,
347 "FASTUVMC unavailable in Simple Profile\n");
350 v->extended_mv = get_bits1(gb); //common
351 if (!v->profile && v->extended_mv)
353 av_log(avctx, AV_LOG_ERROR,
354 "Extended MVs unavailable in Simple Profile\n");
357 v->dquant = get_bits(gb, 2); //common
358 v->vstransform = get_bits1(gb); //common
360 v->res_transtab = get_bits1(gb);
363 av_log(avctx, AV_LOG_ERROR,
364 "1 for reserved RES_TRANSTAB is forbidden\n");
368 v->overlap = get_bits1(gb); //common
370 v->s.resync_marker = get_bits1(gb);
371 v->rangered = get_bits1(gb);
372 if (v->rangered && v->profile == PROFILE_SIMPLE) {
373 av_log(avctx, AV_LOG_INFO,
374 "RANGERED should be set to 0 in Simple Profile\n");
377 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
378 v->quantizer_mode = get_bits(gb, 2); //common
380 v->finterpflag = get_bits1(gb); //common
383 int w = get_bits(gb, 11);
384 int h = get_bits(gb, 11);
385 avcodec_set_dimensions(v->s.avctx, w, h);
386 skip_bits(gb, 5); //frame rate
387 v->res_x8 = get_bits1(gb);
388 if (get_bits1(gb)) { // something to do with DC VLC selection
389 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
392 skip_bits(gb, 3); //slice code
395 v->res_rtm_flag = get_bits1(gb); //reserved
397 if (!v->res_rtm_flag) {
398 // av_log(avctx, AV_LOG_ERROR,
399 // "0 for reserved RES_RTM_FLAG is forbidden\n");
400 av_log(avctx, AV_LOG_ERROR,
401 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
404 //TODO: figure out what they mean (always 0x402F)
407 av_log(avctx, AV_LOG_DEBUG,
408 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
409 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
410 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
411 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
412 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
413 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
414 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
415 v->dquant, v->quantizer_mode, avctx->max_b_frames);
419 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
422 v->level = get_bits(gb, 3);
424 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
426 v->chromaformat = get_bits(gb, 2);
427 if (v->chromaformat != 1) {
428 av_log(v->s.avctx, AV_LOG_ERROR,
429 "Only 4:2:0 chroma format supported\n");
434 v->frmrtq_postproc = get_bits(gb, 3); //common
435 // (bitrate-32kbps)/64kbps
436 v->bitrtq_postproc = get_bits(gb, 5); //common
437 v->postprocflag = get_bits1(gb); //common
439 v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
440 v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
441 v->broadcast = get_bits1(gb);
442 v->interlace = get_bits1(gb);
443 v->tfcntrflag = get_bits1(gb);
444 v->finterpflag = get_bits1(gb);
445 skip_bits1(gb); // reserved
447 av_log(v->s.avctx, AV_LOG_DEBUG,
448 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
449 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
450 "TFCTRflag=%i, FINTERPflag=%i\n",
451 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
452 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
453 v->tfcntrflag, v->finterpflag);
455 v->psf = get_bits1(gb);
456 if (v->psf) { //PsF, 6.1.13
457 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
460 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
461 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
463 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
464 w = get_bits(gb, 14) + 1;
465 h = get_bits(gb, 14) + 1;
466 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
468 ar = get_bits(gb, 4);
470 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
471 } else if (ar == 15) {
472 w = get_bits(gb, 8) + 1;
473 h = get_bits(gb, 8) + 1;
474 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
476 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
477 &v->s.avctx->sample_aspect_ratio.den,
478 v->s.avctx->height * w,
479 v->s.avctx->width * h,
482 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
483 v->s.avctx->sample_aspect_ratio.num,
484 v->s.avctx->sample_aspect_ratio.den);
486 if (get_bits1(gb)) { //framerate stuff
488 v->s.avctx->time_base.num = 32;
489 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
492 nr = get_bits(gb, 8);
493 dr = get_bits(gb, 4);
494 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
495 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
496 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
499 if (v->broadcast) { // Pulldown may be present
500 v->s.avctx->time_base.den *= 2;
501 v->s.avctx->ticks_per_frame = 2;
506 v->s.avctx->color_primaries = get_bits(gb, 8);
507 v->s.avctx->color_trc = get_bits(gb, 8);
508 v->s.avctx->colorspace = get_bits(gb, 8);
509 v->s.avctx->color_range = AVCOL_RANGE_MPEG;
513 v->hrd_param_flag = get_bits1(gb);
514 if (v->hrd_param_flag) {
516 v->hrd_num_leaky_buckets = get_bits(gb, 5);
517 skip_bits(gb, 4); //bitrate exponent
518 skip_bits(gb, 4); //buffer size exponent
519 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
520 skip_bits(gb, 16); //hrd_rate[n]
521 skip_bits(gb, 16); //hrd_buffer[n]
527 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
532 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
533 v->broken_link = get_bits1(gb);
534 v->closed_entry = get_bits1(gb);
535 v->panscanflag = get_bits1(gb);
536 v->refdist_flag = get_bits1(gb);
537 v->s.loop_filter = get_bits1(gb);
538 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
539 v->s.loop_filter = 0;
540 v->fastuvmc = get_bits1(gb);
541 v->extended_mv = get_bits1(gb);
542 v->dquant = get_bits(gb, 2);
543 v->vstransform = get_bits1(gb);
544 v->overlap = get_bits1(gb);
545 v->quantizer_mode = get_bits(gb, 2);
547 if (v->hrd_param_flag) {
548 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
549 skip_bits(gb, 8); //hrd_full[n]
554 w = (get_bits(gb, 12)+1)<<1;
555 h = (get_bits(gb, 12)+1)<<1;
557 w = v->max_coded_width;
558 h = v->max_coded_height;
560 avcodec_set_dimensions(avctx, w, h);
562 v->extended_dmv = get_bits1(gb);
563 if ((v->range_mapy_flag = get_bits1(gb))) {
564 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
565 v->range_mapy = get_bits(gb, 3);
567 if ((v->range_mapuv_flag = get_bits1(gb))) {
568 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
569 v->range_mapuv = get_bits(gb, 3);
572 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
573 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
574 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
575 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
576 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
577 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
582 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
584 int pqindex, lowquant, status;
587 v->interpfrm = get_bits1(gb);
588 if (!v->s.avctx->codec)
590 if (v->s.avctx->codec->id == AV_CODEC_ID_MSS2)
593 v->multires = get_bits(gb, 2) == 1;
595 skip_bits(gb, 2); //framecnt unused
598 v->rangeredfrm = get_bits1(gb);
599 v->s.pict_type = get_bits1(gb);
600 if (v->s.avctx->max_b_frames) {
601 if (!v->s.pict_type) {
603 v->s.pict_type = AV_PICTURE_TYPE_I;
605 v->s.pict_type = AV_PICTURE_TYPE_B;
607 v->s.pict_type = AV_PICTURE_TYPE_P;
609 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
612 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
613 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
614 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
615 if (v->bfraction == 0) {
616 v->s.pict_type = AV_PICTURE_TYPE_BI;
619 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
620 skip_bits(gb, 7); // skip buffer fullness
626 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
628 if (v->s.pict_type == AV_PICTURE_TYPE_P)
631 /* Quantizer stuff */
632 pqindex = get_bits(gb, 5);
635 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
636 v->pq = ff_vc1_pquant_table[0][pqindex];
638 v->pq = ff_vc1_pquant_table[1][pqindex];
641 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
642 v->pquantizer = pqindex < 9;
643 if (v->quantizer_mode == QUANT_NON_UNIFORM)
645 v->pqindex = pqindex;
647 v->halfpq = get_bits1(gb);
650 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
651 v->pquantizer = get_bits1(gb);
653 if (v->extended_mv == 1)
654 v->mvrange = get_unary(gb, 0, 3);
655 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
656 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
657 v->range_x = 1 << (v->k_x - 1);
658 v->range_y = 1 << (v->k_y - 1);
659 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
660 v->respic = get_bits(gb, 2);
662 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
663 v->x8_type = get_bits1(gb);
666 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
667 // (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
669 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
672 switch (v->s.pict_type) {
673 case AV_PICTURE_TYPE_P:
674 if (v->pq < 5) v->tt_index = 0;
675 else if (v->pq < 13) v->tt_index = 1;
676 else v->tt_index = 2;
678 lowquant = (v->pq > 12) ? 0 : 1;
679 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
680 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
682 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
683 v->lumscale = get_bits(gb, 6);
684 v->lumshift = get_bits(gb, 6);
686 /* fill lookup tables for intensity compensation */
689 shift = (255 - v->lumshift * 2) << 6;
690 if (v->lumshift > 31)
693 scale = v->lumscale + 32;
694 if (v->lumshift > 31)
695 shift = (v->lumshift - 64) << 6;
697 shift = v->lumshift << 6;
699 for (i = 0; i < 256; i++) {
700 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
701 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
704 v->qs_last = v->s.quarter_sample;
705 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
706 v->s.quarter_sample = 0;
707 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
708 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
709 v->s.quarter_sample = 0;
711 v->s.quarter_sample = 1;
713 v->s.quarter_sample = 1;
714 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));
716 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
717 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
718 v->mv_mode == MV_PMODE_MIXED_MV) {
719 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
722 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
723 "Imode: %i, Invert: %i\n", status>>1, status&1);
725 v->mv_type_is_raw = 0;
726 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
728 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
731 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
732 "Imode: %i, Invert: %i\n", status>>1, status&1);
734 /* Hopefully this is correct for P frames */
735 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
736 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
739 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
740 vop_dquant_decoding(v);
743 v->ttfrm = 0; //FIXME Is that so ?
744 if (v->vstransform) {
745 v->ttmbf = get_bits1(gb);
747 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
754 case AV_PICTURE_TYPE_B:
755 if (v->pq < 5) v->tt_index = 0;
756 else if (v->pq < 13) v->tt_index = 1;
757 else v->tt_index = 2;
759 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
760 v->qs_last = v->s.quarter_sample;
761 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
762 v->s.mspel = v->s.quarter_sample;
764 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
767 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
768 "Imode: %i, Invert: %i\n", status>>1, status&1);
769 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
772 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
773 "Imode: %i, Invert: %i\n", status>>1, status&1);
775 v->s.mv_table_index = get_bits(gb, 2);
776 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
779 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
780 vop_dquant_decoding(v);
784 if (v->vstransform) {
785 v->ttmbf = get_bits1(gb);
787 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
798 v->c_ac_table_index = decode012(gb);
799 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
800 v->y_ac_table_index = decode012(gb);
803 v->s.dc_table_index = get_bits1(gb);
806 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
807 v->s.pict_type = AV_PICTURE_TYPE_B;
813 /* fill lookup tables for intensity compensation */
814 #define INIT_LUT(lumscale, lumshift, luty, lutuv) \
817 shift = (255 - lumshift * 2) << 6; \
821 scale = lumscale + 32; \
823 shift = (lumshift - 64) << 6; \
825 shift = lumshift << 6; \
827 for (i = 0; i < 256; i++) { \
828 luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); \
829 lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); \
832 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
834 int pqindex, lowquant;
836 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
837 int scale, shift, i; /* for initializing LUT for intensity compensation */
840 v->p_frame_skipped = 0;
841 if (v->second_field) {
842 if(v->fcm!=2 || v->field_mode!=1)
844 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
846 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
847 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
848 if (!v->pic_header_flag)
849 goto parse_common_info;
854 v->fcm = decode012(gb);
856 if (v->fcm == ILACE_FIELD)
858 if (!v->warn_interlaced++)
859 av_log(v->s.avctx, AV_LOG_ERROR,
860 "Interlaced frames/fields support is incomplete\n");
863 v->fcm = PROGRESSIVE;
867 v->fptype = get_bits(gb, 3);
868 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
869 if (v->fptype & 4) // B-picture
870 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
872 switch (get_unary(gb, 0, 4)) {
874 v->s.pict_type = AV_PICTURE_TYPE_P;
877 v->s.pict_type = AV_PICTURE_TYPE_B;
880 v->s.pict_type = AV_PICTURE_TYPE_I;
883 v->s.pict_type = AV_PICTURE_TYPE_BI;
886 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
887 v->p_frame_skipped = 1;
894 if (!v->interlace || v->psf) {
895 v->rptfrm = get_bits(gb, 2);
897 v->tff = get_bits1(gb);
898 v->rff = get_bits1(gb);
901 if (v->panscanflag) {
902 av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
905 if (v->p_frame_skipped) {
908 v->rnd = get_bits1(gb);
910 v->uvsamp = get_bits1(gb);
911 if(!ff_vc1_bfraction_vlc.table)
912 return 0; //parsing only, vlc tables havnt been allocated
914 if (!v->refdist_flag)
916 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
917 v->refdist = get_bits(gb, 2);
919 v->refdist += get_unary(gb, 0, 16);
921 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
922 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
923 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
924 v->frfd = (v->bfraction * v->refdist) >> 8;
925 v->brfd = v->refdist - v->frfd - 1;
929 goto parse_common_info;
931 if (v->fcm == PROGRESSIVE) {
933 v->interpfrm = get_bits1(gb);
934 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
935 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
936 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
937 if (v->bfraction == 0) {
938 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
945 v->cur_field_type = !(v->tff ^ v->second_field);
946 pqindex = get_bits(gb, 5);
949 v->pqindex = pqindex;
950 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
951 v->pq = ff_vc1_pquant_table[0][pqindex];
953 v->pq = ff_vc1_pquant_table[1][pqindex];
956 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
957 v->pquantizer = pqindex < 9;
958 if (v->quantizer_mode == QUANT_NON_UNIFORM)
960 v->pqindex = pqindex;
962 v->halfpq = get_bits1(gb);
965 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
966 v->pquantizer = get_bits1(gb);
968 v->postproc = get_bits(gb, 2);
970 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
976 switch (v->s.pict_type) {
977 case AV_PICTURE_TYPE_I:
978 case AV_PICTURE_TYPE_BI:
979 if (v->fcm == ILACE_FRAME) { //interlace frame picture
980 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
983 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
984 "Imode: %i, Invert: %i\n", status>>1, status&1);
986 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
989 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
990 "Imode: %i, Invert: %i\n", status>>1, status&1);
991 v->condover = CONDOVER_NONE;
992 if (v->overlap && v->pq <= 8) {
993 v->condover = decode012(gb);
994 if (v->condover == CONDOVER_SELECT) {
995 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
998 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
999 "Imode: %i, Invert: %i\n", status>>1, status&1);
1003 case AV_PICTURE_TYPE_P:
1004 if (v->field_mode) {
1005 v->numref = get_bits1(gb);
1007 v->reffield = get_bits1(gb);
1008 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1012 v->mvrange = get_unary(gb, 0, 3);
1016 if (v->extended_dmv)
1017 v->dmvrange = get_unary(gb, 0, 3);
1020 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1021 v->fourmvswitch = get_bits1(gb);
1022 v->intcomp = get_bits1(gb);
1024 v->lumscale = get_bits(gb, 6);
1025 v->lumshift = get_bits(gb, 6);
1026 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1028 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1029 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1030 "Imode: %i, Invert: %i\n", status>>1, status&1);
1031 mbmodetab = get_bits(gb, 2);
1032 if (v->fourmvswitch)
1033 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1035 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1036 imvtab = get_bits(gb, 2);
1037 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1038 // interlaced p-picture cbpcy range is [1, 63]
1039 icbptab = get_bits(gb, 3);
1040 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1041 twomvbptab = get_bits(gb, 2);
1042 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1043 if (v->fourmvswitch) {
1044 fourmvbptab = get_bits(gb, 2);
1045 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1049 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1050 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1051 v->range_x = 1 << (v->k_x - 1);
1052 v->range_y = 1 << (v->k_y - 1);
1056 else if (v->pq < 13)
1060 if (v->fcm != ILACE_FRAME) {
1062 mvmode = get_unary(gb, 1, 4);
1063 lowquant = (v->pq > 12) ? 0 : 1;
1064 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1065 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1067 mvmode2 = get_unary(gb, 1, 3);
1068 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1070 v->intcompfield = decode210(gb);
1071 v->lumscale = get_bits(gb, 6);
1072 v->lumshift = get_bits(gb, 6);
1073 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1074 if ((v->field_mode) && !v->intcompfield) {
1075 v->lumscale2 = get_bits(gb, 6);
1076 v->lumshift2 = get_bits(gb, 6);
1077 INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
1081 v->qs_last = v->s.quarter_sample;
1082 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1083 v->s.quarter_sample = 0;
1084 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1085 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1086 v->s.quarter_sample = 0;
1088 v->s.quarter_sample = 1;
1090 v->s.quarter_sample = 1;
1091 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1092 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1093 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1095 if (v->fcm == PROGRESSIVE) { // progressive
1096 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1097 v->mv_mode2 == MV_PMODE_MIXED_MV)
1098 || v->mv_mode == MV_PMODE_MIXED_MV) {
1099 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1102 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1103 "Imode: %i, Invert: %i\n", status>>1, status&1);
1105 v->mv_type_is_raw = 0;
1106 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1108 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1111 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1112 "Imode: %i, Invert: %i\n", status>>1, status&1);
1114 /* Hopefully this is correct for P frames */
1115 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1116 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1117 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1118 v->qs_last = v->s.quarter_sample;
1119 v->s.quarter_sample = 1;
1121 } else { // field interlaced
1122 mbmodetab = get_bits(gb, 3);
1123 imvtab = get_bits(gb, 2 + v->numref);
1125 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1127 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1128 icbptab = get_bits(gb, 3);
1129 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1130 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1131 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1132 fourmvbptab = get_bits(gb, 2);
1133 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1134 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1136 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1140 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1141 vop_dquant_decoding(v);
1144 v->ttfrm = 0; //FIXME Is that so ?
1145 if (v->vstransform) {
1146 v->ttmbf = get_bits1(gb);
1148 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1155 case AV_PICTURE_TYPE_B:
1156 if (v->fcm == ILACE_FRAME) {
1157 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1158 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1159 if (v->bfraction == 0) {
1162 return -1; // This codepath is still incomplete thus it is disabled
1165 v->mvrange = get_unary(gb, 0, 3);
1168 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1169 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1170 v->range_x = 1 << (v->k_x - 1);
1171 v->range_y = 1 << (v->k_y - 1);
1175 else if (v->pq < 13)
1180 if (v->field_mode) {
1182 av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1183 if (v->extended_dmv)
1184 v->dmvrange = get_unary(gb, 0, 3);
1185 mvmode = get_unary(gb, 1, 3);
1186 lowquant = (v->pq > 12) ? 0 : 1;
1187 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1188 v->qs_last = v->s.quarter_sample;
1189 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1190 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1191 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1194 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1195 "Imode: %i, Invert: %i\n", status>>1, status&1);
1196 mbmodetab = get_bits(gb, 3);
1197 if (v->mv_mode == MV_PMODE_MIXED_MV)
1198 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1200 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1201 imvtab = get_bits(gb, 3);
1202 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1203 icbptab = get_bits(gb, 3);
1204 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1205 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1206 fourmvbptab = get_bits(gb, 2);
1207 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1209 v->numref = 1; // interlaced field B pictures are always 2-ref
1210 } else if (v->fcm == ILACE_FRAME) {
1211 if (v->extended_dmv)
1212 v->dmvrange = get_unary(gb, 0, 3);
1213 get_bits1(gb); /* intcomp - present but shall always be 0 */
1215 v->mv_mode = MV_PMODE_1MV;
1216 v->fourmvswitch = 0;
1217 v->qs_last = v->s.quarter_sample;
1218 v->s.quarter_sample = 1;
1220 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1223 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1224 "Imode: %i, Invert: %i\n", status>>1, status&1);
1225 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1228 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1229 "Imode: %i, Invert: %i\n", status>>1, status&1);
1230 mbmodetab = get_bits(gb, 2);
1231 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1232 imvtab = get_bits(gb, 2);
1233 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1234 // interlaced p/b-picture cbpcy range is [1, 63]
1235 icbptab = get_bits(gb, 3);
1236 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1237 twomvbptab = get_bits(gb, 2);
1238 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1239 fourmvbptab = get_bits(gb, 2);
1240 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1242 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1243 v->qs_last = v->s.quarter_sample;
1244 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1245 v->s.mspel = v->s.quarter_sample;
1246 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1249 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1250 "Imode: %i, Invert: %i\n", status>>1, status&1);
1251 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1254 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1255 "Imode: %i, Invert: %i\n", status>>1, status&1);
1256 v->s.mv_table_index = get_bits(gb, 2);
1257 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1261 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1262 vop_dquant_decoding(v);
1266 if (v->vstransform) {
1267 v->ttmbf = get_bits1(gb);
1269 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1279 v->c_ac_table_index = decode012(gb);
1280 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1281 v->y_ac_table_index = decode012(gb);
1284 v->s.dc_table_index = get_bits1(gb);
1285 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1287 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1288 vop_dquant_decoding(v);
1292 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1293 v->s.pict_type = AV_PICTURE_TYPE_B;
1299 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1301 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1302 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1303 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1304 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1305 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1306 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1307 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1308 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1309 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1310 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1311 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1312 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1313 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1314 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1315 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1316 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1317 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1318 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1319 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1320 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1321 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1322 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1323 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1324 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1325 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1326 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1327 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1328 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1329 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1330 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1331 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1334 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1335 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1336 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1337 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1338 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1339 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1340 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1341 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1342 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1343 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1344 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1345 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1346 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1347 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1348 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1349 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1350 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1351 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1352 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1353 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1354 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1355 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1356 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1357 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1358 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1359 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1360 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1361 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1365 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1366 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1367 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1368 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1369 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1370 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1371 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1372 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1373 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1374 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1375 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1376 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1377 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1378 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1379 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1380 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1381 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1382 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1383 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1384 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1385 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1386 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1390 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1391 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1392 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1393 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1394 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1395 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1396 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1397 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1398 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1399 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1400 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1401 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1402 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1403 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1404 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1405 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1406 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1407 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1408 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1409 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1410 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1411 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1412 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1413 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1414 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1417 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1418 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1419 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1420 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1421 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1422 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1423 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1424 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1425 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1426 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1427 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1428 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1429 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1430 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1431 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1432 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1433 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1437 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1438 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1439 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1440 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1441 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1442 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1443 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1444 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1445 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1446 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1447 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1448 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1449 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1450 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1451 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1452 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1453 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1457 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1458 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1459 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1460 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1461 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1462 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1463 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1464 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1465 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1466 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1467 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1468 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1469 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1470 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1471 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1472 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1473 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1474 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1475 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1476 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1477 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1478 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1479 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1480 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1481 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1482 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1483 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1487 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1488 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1489 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1490 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1491 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1492 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1493 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1494 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1495 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1496 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1497 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1498 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1499 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1500 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1501 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1502 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1503 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1504 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1505 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1506 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1507 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1508 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1509 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1510 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1511 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1512 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1513 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1514 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1515 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1520 static const uint16_t vlc_offs[] = {
1521 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1522 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1523 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1524 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1525 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1526 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1527 31714, 31746, 31778, 32306, 32340, 32372
1531 * Init VC-1 specific tables and VC1Context members
1532 * @param v The VC1Context to initialize
1535 int ff_vc1_init_common(VC1Context *v)
1537 static int done = 0;
1539 static VLC_TYPE vlc_table[32372][2];
1541 v->hrd_rate = v->hrd_buffer = NULL;
1545 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1546 ff_vc1_bfraction_bits, 1, 1,
1547 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1548 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1549 ff_vc1_norm2_bits, 1, 1,
1550 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1551 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1552 ff_vc1_norm6_bits, 1, 1,
1553 ff_vc1_norm6_codes, 2, 2, 556);
1554 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1555 ff_vc1_imode_bits, 1, 1,
1556 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1557 for (i = 0; i < 3; i++) {
1558 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1559 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1560 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1561 ff_vc1_ttmb_bits[i], 1, 1,
1562 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1563 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1564 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1565 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1566 ff_vc1_ttblk_bits[i], 1, 1,
1567 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1568 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1569 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1570 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1571 ff_vc1_subblkpat_bits[i], 1, 1,
1572 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1574 for (i = 0; i < 4; i++) {
1575 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1576 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1577 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1578 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1579 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1580 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1581 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1582 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1583 ff_vc1_cbpcy_p_bits[i], 1, 1,
1584 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1585 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1586 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1587 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1588 ff_vc1_mv_diff_bits[i], 1, 1,
1589 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1591 for (i = 0; i < 8; i++) {
1592 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1593 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1594 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1595 &vc1_ac_tables[i][0][1], 8, 4,
1596 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1597 /* initialize interlaced MVDATA tables (2-Ref) */
1598 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1599 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1600 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1601 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1602 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1604 for (i = 0; i < 4; i++) {
1605 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1606 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1607 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1608 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1609 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1610 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1611 /* initialize NON-4MV MBMODE VLC tables for the same */
1612 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1613 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1614 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1615 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1616 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1617 /* initialize interlaced MVDATA tables (1-Ref) */
1618 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1619 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1620 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1621 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1622 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1624 for (i = 0; i < 4; i++) {
1625 /* Initialize 2MV Block pattern VLC tables */
1626 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1627 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1628 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1629 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1630 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1632 for (i = 0; i < 8; i++) {
1633 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1634 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1635 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1636 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1637 ff_vc1_icbpcy_p_bits[i], 1, 1,
1638 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1639 /* Initialize interlaced field picture MBMODE VLC tables */
1640 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1641 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1642 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1643 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1644 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1645 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1646 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1647 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1648 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1649 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1654 /* Other defaults */
1656 v->mvrange = 0; /* 7.1.1.18, p80 */