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 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
402 //TODO: figure out what they mean (always 0x402F)
405 av_log(avctx, AV_LOG_DEBUG,
406 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
407 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
408 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
409 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
410 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
411 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
412 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
413 v->dquant, v->quantizer_mode, avctx->max_b_frames);
417 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
420 v->level = get_bits(gb, 3);
422 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
424 v->chromaformat = get_bits(gb, 2);
425 if (v->chromaformat != 1) {
426 av_log(v->s.avctx, AV_LOG_ERROR,
427 "Only 4:2:0 chroma format supported\n");
432 v->frmrtq_postproc = get_bits(gb, 3); //common
433 // (bitrate-32kbps)/64kbps
434 v->bitrtq_postproc = get_bits(gb, 5); //common
435 v->postprocflag = get_bits1(gb); //common
437 v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
438 v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
439 v->broadcast = get_bits1(gb);
440 v->interlace = get_bits1(gb);
441 v->tfcntrflag = get_bits1(gb);
442 v->finterpflag = get_bits1(gb);
443 skip_bits1(gb); // reserved
445 av_log(v->s.avctx, AV_LOG_DEBUG,
446 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
447 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
448 "TFCTRflag=%i, FINTERPflag=%i\n",
449 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
450 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
451 v->tfcntrflag, v->finterpflag);
453 v->psf = get_bits1(gb);
454 if (v->psf) { //PsF, 6.1.13
455 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
458 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
459 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
461 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
462 w = get_bits(gb, 14) + 1;
463 h = get_bits(gb, 14) + 1;
464 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
466 ar = get_bits(gb, 4);
468 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
469 } else if (ar == 15) {
470 w = get_bits(gb, 8) + 1;
471 h = get_bits(gb, 8) + 1;
472 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
474 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
475 &v->s.avctx->sample_aspect_ratio.den,
476 v->s.avctx->height * w,
477 v->s.avctx->width * h,
480 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
481 v->s.avctx->sample_aspect_ratio.num,
482 v->s.avctx->sample_aspect_ratio.den);
484 if (get_bits1(gb)) { //framerate stuff
486 v->s.avctx->time_base.num = 32;
487 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
490 nr = get_bits(gb, 8);
491 dr = get_bits(gb, 4);
492 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
493 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
494 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
497 if (v->broadcast) { // Pulldown may be present
498 v->s.avctx->time_base.den *= 2;
499 v->s.avctx->ticks_per_frame = 2;
504 v->s.avctx->color_primaries = get_bits(gb, 8);
505 v->s.avctx->color_trc = get_bits(gb, 8);
506 v->s.avctx->colorspace = get_bits(gb, 8);
507 v->s.avctx->color_range = AVCOL_RANGE_MPEG;
511 v->hrd_param_flag = get_bits1(gb);
512 if (v->hrd_param_flag) {
514 v->hrd_num_leaky_buckets = get_bits(gb, 5);
515 skip_bits(gb, 4); //bitrate exponent
516 skip_bits(gb, 4); //buffer size exponent
517 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
518 skip_bits(gb, 16); //hrd_rate[n]
519 skip_bits(gb, 16); //hrd_buffer[n]
525 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
530 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
531 v->broken_link = get_bits1(gb);
532 v->closed_entry = get_bits1(gb);
533 v->panscanflag = get_bits1(gb);
534 v->refdist_flag = get_bits1(gb);
535 v->s.loop_filter = get_bits1(gb);
536 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
537 v->s.loop_filter = 0;
538 v->fastuvmc = get_bits1(gb);
539 v->extended_mv = get_bits1(gb);
540 v->dquant = get_bits(gb, 2);
541 v->vstransform = get_bits1(gb);
542 v->overlap = get_bits1(gb);
543 v->quantizer_mode = get_bits(gb, 2);
545 if (v->hrd_param_flag) {
546 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
547 skip_bits(gb, 8); //hrd_full[n]
552 w = (get_bits(gb, 12)+1)<<1;
553 h = (get_bits(gb, 12)+1)<<1;
555 w = v->max_coded_width;
556 h = v->max_coded_height;
558 avcodec_set_dimensions(avctx, w, h);
560 v->extended_dmv = get_bits1(gb);
561 if ((v->range_mapy_flag = get_bits1(gb))) {
562 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
563 v->range_mapy = get_bits(gb, 3);
565 if ((v->range_mapuv_flag = get_bits1(gb))) {
566 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
567 v->range_mapuv = get_bits(gb, 3);
570 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
571 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
572 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
573 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
574 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
575 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
580 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
582 int pqindex, lowquant, status;
585 v->interpfrm = get_bits1(gb);
586 if (!v->s.avctx->codec)
588 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
591 v->multires = get_bits(gb, 2) == 1;
593 skip_bits(gb, 2); //framecnt unused
596 v->rangeredfrm = get_bits1(gb);
597 v->s.pict_type = get_bits1(gb);
598 if (v->s.avctx->max_b_frames) {
599 if (!v->s.pict_type) {
601 v->s.pict_type = AV_PICTURE_TYPE_I;
603 v->s.pict_type = AV_PICTURE_TYPE_B;
605 v->s.pict_type = AV_PICTURE_TYPE_P;
607 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
610 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
611 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
612 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
613 if (v->bfraction == 0) {
614 v->s.pict_type = AV_PICTURE_TYPE_BI;
617 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
618 skip_bits(gb, 7); // skip buffer fullness
624 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
626 if (v->s.pict_type == AV_PICTURE_TYPE_P)
629 /* Quantizer stuff */
630 pqindex = get_bits(gb, 5);
633 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
634 v->pq = ff_vc1_pquant_table[0][pqindex];
636 v->pq = ff_vc1_pquant_table[1][pqindex];
639 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
640 v->pquantizer = pqindex < 9;
641 if (v->quantizer_mode == QUANT_NON_UNIFORM)
643 v->pqindex = pqindex;
645 v->halfpq = get_bits1(gb);
648 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
649 v->pquantizer = get_bits1(gb);
651 if (v->extended_mv == 1)
652 v->mvrange = get_unary(gb, 0, 3);
653 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
654 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
655 v->range_x = 1 << (v->k_x - 1);
656 v->range_y = 1 << (v->k_y - 1);
657 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
658 v->respic = get_bits(gb, 2);
660 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
661 v->x8_type = get_bits1(gb);
664 av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
665 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
666 pqindex, v->pq, v->halfpq, v->rangeredfrm);
668 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
671 switch (v->s.pict_type) {
672 case AV_PICTURE_TYPE_P:
673 if (v->pq < 5) v->tt_index = 0;
674 else if (v->pq < 13) v->tt_index = 1;
675 else v->tt_index = 2;
677 lowquant = (v->pq > 12) ? 0 : 1;
678 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
679 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
681 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
682 v->lumscale = get_bits(gb, 6);
683 v->lumshift = get_bits(gb, 6);
685 /* fill lookup tables for intensity compensation */
688 shift = (255 - v->lumshift * 2) << 6;
689 if (v->lumshift > 31)
692 scale = v->lumscale + 32;
693 if (v->lumshift > 31)
694 shift = (v->lumshift - 64) << 6;
696 shift = v->lumshift << 6;
698 for (i = 0; i < 256; i++) {
699 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
700 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
703 v->qs_last = v->s.quarter_sample;
704 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
705 v->s.quarter_sample = 0;
706 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
707 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
708 v->s.quarter_sample = 0;
710 v->s.quarter_sample = 1;
712 v->s.quarter_sample = 1;
713 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));
715 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
716 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
717 v->mv_mode == MV_PMODE_MIXED_MV) {
718 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
721 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
722 "Imode: %i, Invert: %i\n", status>>1, status&1);
724 v->mv_type_is_raw = 0;
725 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
727 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
730 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
731 "Imode: %i, Invert: %i\n", status>>1, status&1);
733 /* Hopefully this is correct for P frames */
734 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
735 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
738 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
739 vop_dquant_decoding(v);
742 v->ttfrm = 0; //FIXME Is that so ?
743 if (v->vstransform) {
744 v->ttmbf = get_bits1(gb);
746 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
753 case AV_PICTURE_TYPE_B:
754 if (v->pq < 5) v->tt_index = 0;
755 else if (v->pq < 13) v->tt_index = 1;
756 else v->tt_index = 2;
758 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
759 v->qs_last = v->s.quarter_sample;
760 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
761 v->s.mspel = v->s.quarter_sample;
763 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
766 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
767 "Imode: %i, Invert: %i\n", status>>1, status&1);
768 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
771 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
772 "Imode: %i, Invert: %i\n", status>>1, status&1);
774 v->s.mv_table_index = get_bits(gb, 2);
775 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
778 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
779 vop_dquant_decoding(v);
783 if (v->vstransform) {
784 v->ttmbf = get_bits1(gb);
786 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
797 v->c_ac_table_index = decode012(gb);
798 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
799 v->y_ac_table_index = decode012(gb);
802 v->s.dc_table_index = get_bits1(gb);
805 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
806 v->s.pict_type = AV_PICTURE_TYPE_B;
812 /* fill lookup tables for intensity compensation */
813 #define INIT_LUT(lumscale, lumshift, luty, lutuv) \
816 shift = (255 - lumshift * 2) << 6; \
820 scale = lumscale + 32; \
822 shift = (lumshift - 64) << 6; \
824 shift = lumshift << 6; \
826 for (i = 0; i < 256; i++) { \
827 luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); \
828 lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); \
831 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
833 int pqindex, lowquant;
835 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
836 int scale, shift, i; /* for initializing LUT for intensity compensation */
839 v->p_frame_skipped = 0;
840 if (v->second_field) {
841 if(v->fcm!=2 || v->field_mode!=1)
843 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
845 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
846 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
847 if (!v->pic_header_flag)
848 goto parse_common_info;
853 v->fcm = decode012(gb);
855 if (v->fcm == ILACE_FIELD)
857 if (!v->warn_interlaced++)
858 av_log(v->s.avctx, AV_LOG_ERROR,
859 "Interlaced frames/fields support is incomplete\n");
862 v->fcm = PROGRESSIVE;
866 v->fptype = get_bits(gb, 3);
867 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
868 if (v->fptype & 4) // B-picture
869 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
871 switch (get_unary(gb, 0, 4)) {
873 v->s.pict_type = AV_PICTURE_TYPE_P;
876 v->s.pict_type = AV_PICTURE_TYPE_B;
879 v->s.pict_type = AV_PICTURE_TYPE_I;
882 v->s.pict_type = AV_PICTURE_TYPE_BI;
885 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
886 v->p_frame_skipped = 1;
893 if (!v->interlace || v->psf) {
894 v->rptfrm = get_bits(gb, 2);
896 v->tff = get_bits1(gb);
897 v->rff = get_bits1(gb);
900 if (v->panscanflag) {
901 av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
904 if (v->p_frame_skipped) {
907 v->rnd = get_bits1(gb);
909 v->uvsamp = get_bits1(gb);
910 if(!ff_vc1_bfraction_vlc.table)
911 return 0; //parsing only, vlc tables havnt been allocated
913 if (!v->refdist_flag)
915 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
916 v->refdist = get_bits(gb, 2);
918 v->refdist += get_unary(gb, 0, 16);
920 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
921 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
922 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
923 v->frfd = (v->bfraction * v->refdist) >> 8;
924 v->brfd = v->refdist - v->frfd - 1;
928 goto parse_common_info;
930 if (v->fcm == PROGRESSIVE) {
932 v->interpfrm = get_bits1(gb);
933 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
934 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
935 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
936 if (v->bfraction == 0) {
937 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
944 v->cur_field_type = !(v->tff ^ v->second_field);
945 pqindex = get_bits(gb, 5);
948 v->pqindex = pqindex;
949 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
950 v->pq = ff_vc1_pquant_table[0][pqindex];
952 v->pq = ff_vc1_pquant_table[1][pqindex];
955 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
956 v->pquantizer = pqindex < 9;
957 if (v->quantizer_mode == QUANT_NON_UNIFORM)
959 v->pqindex = pqindex;
961 v->halfpq = get_bits1(gb);
964 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
965 v->pquantizer = get_bits1(gb);
967 v->postproc = get_bits(gb, 2);
969 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
975 switch (v->s.pict_type) {
976 case AV_PICTURE_TYPE_I:
977 case AV_PICTURE_TYPE_BI:
978 if (v->fcm == ILACE_FRAME) { //interlace frame picture
979 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
982 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
983 "Imode: %i, Invert: %i\n", status>>1, status&1);
985 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
988 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
989 "Imode: %i, Invert: %i\n", status>>1, status&1);
990 v->condover = CONDOVER_NONE;
991 if (v->overlap && v->pq <= 8) {
992 v->condover = decode012(gb);
993 if (v->condover == CONDOVER_SELECT) {
994 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
997 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
998 "Imode: %i, Invert: %i\n", status>>1, status&1);
1002 case AV_PICTURE_TYPE_P:
1003 if (v->field_mode) {
1004 v->numref = get_bits1(gb);
1006 v->reffield = get_bits1(gb);
1007 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1011 v->mvrange = get_unary(gb, 0, 3);
1015 if (v->extended_dmv)
1016 v->dmvrange = get_unary(gb, 0, 3);
1019 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1020 v->fourmvswitch = get_bits1(gb);
1021 v->intcomp = get_bits1(gb);
1023 v->lumscale = get_bits(gb, 6);
1024 v->lumshift = get_bits(gb, 6);
1025 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1027 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1028 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1029 "Imode: %i, Invert: %i\n", status>>1, status&1);
1030 mbmodetab = get_bits(gb, 2);
1031 if (v->fourmvswitch)
1032 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1034 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1035 imvtab = get_bits(gb, 2);
1036 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1037 // interlaced p-picture cbpcy range is [1, 63]
1038 icbptab = get_bits(gb, 3);
1039 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1040 twomvbptab = get_bits(gb, 2);
1041 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1042 if (v->fourmvswitch) {
1043 fourmvbptab = get_bits(gb, 2);
1044 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1048 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1049 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1050 v->range_x = 1 << (v->k_x - 1);
1051 v->range_y = 1 << (v->k_y - 1);
1055 else if (v->pq < 13)
1059 if (v->fcm != ILACE_FRAME) {
1061 mvmode = get_unary(gb, 1, 4);
1062 lowquant = (v->pq > 12) ? 0 : 1;
1063 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1064 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1066 mvmode2 = get_unary(gb, 1, 3);
1067 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1069 v->intcompfield = decode210(gb);
1070 v->lumscale = get_bits(gb, 6);
1071 v->lumshift = get_bits(gb, 6);
1072 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1073 if ((v->field_mode) && !v->intcompfield) {
1074 v->lumscale2 = get_bits(gb, 6);
1075 v->lumshift2 = get_bits(gb, 6);
1076 INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
1080 v->qs_last = v->s.quarter_sample;
1081 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1082 v->s.quarter_sample = 0;
1083 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1084 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1085 v->s.quarter_sample = 0;
1087 v->s.quarter_sample = 1;
1089 v->s.quarter_sample = 1;
1090 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1091 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1092 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1094 if (v->fcm == PROGRESSIVE) { // progressive
1095 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1096 v->mv_mode2 == MV_PMODE_MIXED_MV)
1097 || v->mv_mode == MV_PMODE_MIXED_MV) {
1098 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1101 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1102 "Imode: %i, Invert: %i\n", status>>1, status&1);
1104 v->mv_type_is_raw = 0;
1105 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1107 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1110 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1111 "Imode: %i, Invert: %i\n", status>>1, status&1);
1113 /* Hopefully this is correct for P frames */
1114 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1115 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1116 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1117 v->qs_last = v->s.quarter_sample;
1118 v->s.quarter_sample = 1;
1120 } else { // field interlaced
1121 mbmodetab = get_bits(gb, 3);
1122 imvtab = get_bits(gb, 2 + v->numref);
1124 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1126 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1127 icbptab = get_bits(gb, 3);
1128 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1129 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1130 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1131 fourmvbptab = get_bits(gb, 2);
1132 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1133 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1135 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1139 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1140 vop_dquant_decoding(v);
1143 v->ttfrm = 0; //FIXME Is that so ?
1144 if (v->vstransform) {
1145 v->ttmbf = get_bits1(gb);
1147 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1154 case AV_PICTURE_TYPE_B:
1155 if (v->fcm == ILACE_FRAME) {
1156 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1157 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1158 if (v->bfraction == 0) {
1163 v->mvrange = get_unary(gb, 0, 3);
1166 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1167 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1168 v->range_x = 1 << (v->k_x - 1);
1169 v->range_y = 1 << (v->k_y - 1);
1173 else if (v->pq < 13)
1178 if (v->field_mode) {
1180 av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1181 if (v->extended_dmv)
1182 v->dmvrange = get_unary(gb, 0, 3);
1183 mvmode = get_unary(gb, 1, 3);
1184 lowquant = (v->pq > 12) ? 0 : 1;
1185 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1186 v->qs_last = v->s.quarter_sample;
1187 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1188 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1189 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1192 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1193 "Imode: %i, Invert: %i\n", status>>1, status&1);
1194 mbmodetab = get_bits(gb, 3);
1195 if (v->mv_mode == MV_PMODE_MIXED_MV)
1196 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1198 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1199 imvtab = get_bits(gb, 3);
1200 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1201 icbptab = get_bits(gb, 3);
1202 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1203 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1204 fourmvbptab = get_bits(gb, 2);
1205 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1207 v->numref = 1; // interlaced field B pictures are always 2-ref
1208 } else if (v->fcm == ILACE_FRAME) {
1209 if (v->extended_dmv)
1210 v->dmvrange = get_unary(gb, 0, 3);
1211 get_bits1(gb); /* intcomp - present but shall always be 0 */
1213 v->mv_mode = MV_PMODE_1MV;
1214 v->fourmvswitch = 0;
1215 v->qs_last = v->s.quarter_sample;
1216 v->s.quarter_sample = 1;
1218 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1221 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1222 "Imode: %i, Invert: %i\n", status>>1, status&1);
1223 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1226 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1227 "Imode: %i, Invert: %i\n", status>>1, status&1);
1228 mbmodetab = get_bits(gb, 2);
1229 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1230 imvtab = get_bits(gb, 2);
1231 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1232 // interlaced p/b-picture cbpcy range is [1, 63]
1233 icbptab = get_bits(gb, 3);
1234 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1235 twomvbptab = get_bits(gb, 2);
1236 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1237 fourmvbptab = get_bits(gb, 2);
1238 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1240 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1241 v->qs_last = v->s.quarter_sample;
1242 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1243 v->s.mspel = v->s.quarter_sample;
1244 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1247 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1248 "Imode: %i, Invert: %i\n", status>>1, status&1);
1249 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1252 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1253 "Imode: %i, Invert: %i\n", status>>1, status&1);
1254 v->s.mv_table_index = get_bits(gb, 2);
1255 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1259 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1260 vop_dquant_decoding(v);
1264 if (v->vstransform) {
1265 v->ttmbf = get_bits1(gb);
1267 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1276 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1282 v->c_ac_table_index = decode012(gb);
1283 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1284 v->y_ac_table_index = decode012(gb);
1287 v->s.dc_table_index = get_bits1(gb);
1288 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1290 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1291 vop_dquant_decoding(v);
1295 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1296 v->s.pict_type = AV_PICTURE_TYPE_B;
1302 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1304 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1305 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1306 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1307 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1308 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1309 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1310 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1311 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1312 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1313 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1314 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1315 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1316 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1317 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1318 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1319 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1320 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1321 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1322 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1323 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1324 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1325 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1326 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1327 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1328 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1329 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1330 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1331 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1332 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1333 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1334 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1337 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1338 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1339 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1340 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1341 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1342 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1343 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1344 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1345 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1346 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1347 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1348 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1349 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1350 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1351 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1352 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1353 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1354 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1355 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1356 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1357 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1358 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1359 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1360 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1361 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1362 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1363 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1364 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1368 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1369 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1370 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1371 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1372 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1373 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1374 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1375 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1376 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1377 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1378 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1379 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1380 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1381 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1382 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1383 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1384 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1385 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1386 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1387 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1388 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1389 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1393 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1394 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1395 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1396 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1397 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1398 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1399 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1400 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1401 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1402 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1403 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1404 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1405 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1406 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1407 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1408 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1409 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1410 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1411 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1412 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1413 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1414 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1415 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1416 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1417 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1420 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1421 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1422 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1423 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1424 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1425 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1426 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1427 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1428 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1429 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1430 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1431 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1432 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1433 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1434 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1435 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1436 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1440 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1441 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1442 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1443 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1444 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1445 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1446 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1447 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1448 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1449 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1450 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1451 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1452 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1453 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1454 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1455 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1456 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1460 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1461 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1462 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1463 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1464 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1465 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1466 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1467 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1468 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1469 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1470 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1471 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1472 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1473 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1474 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1475 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1476 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1477 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1478 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1479 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1480 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1481 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1482 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1483 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1484 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1485 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1486 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1490 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1491 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1492 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1493 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1494 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1495 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1496 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1497 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1498 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1499 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1500 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1501 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1502 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1503 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1504 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1505 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1506 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1507 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1508 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1509 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1510 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1511 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1512 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1513 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1514 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1515 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1516 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1517 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1518 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1523 static const uint16_t vlc_offs[] = {
1524 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1525 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1526 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1527 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1528 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1529 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1530 31714, 31746, 31778, 32306, 32340, 32372
1534 * Init VC-1 specific tables and VC1Context members
1535 * @param v The VC1Context to initialize
1538 int ff_vc1_init_common(VC1Context *v)
1540 static int done = 0;
1542 static VLC_TYPE vlc_table[32372][2];
1544 v->hrd_rate = v->hrd_buffer = NULL;
1548 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1549 ff_vc1_bfraction_bits, 1, 1,
1550 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1551 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1552 ff_vc1_norm2_bits, 1, 1,
1553 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1554 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1555 ff_vc1_norm6_bits, 1, 1,
1556 ff_vc1_norm6_codes, 2, 2, 556);
1557 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1558 ff_vc1_imode_bits, 1, 1,
1559 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1560 for (i = 0; i < 3; i++) {
1561 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1562 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1563 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1564 ff_vc1_ttmb_bits[i], 1, 1,
1565 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1566 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1567 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1568 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1569 ff_vc1_ttblk_bits[i], 1, 1,
1570 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1571 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1572 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1573 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1574 ff_vc1_subblkpat_bits[i], 1, 1,
1575 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1577 for (i = 0; i < 4; i++) {
1578 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1579 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1580 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1581 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1582 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1583 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1584 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1585 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1586 ff_vc1_cbpcy_p_bits[i], 1, 1,
1587 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1588 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1589 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1590 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1591 ff_vc1_mv_diff_bits[i], 1, 1,
1592 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1594 for (i = 0; i < 8; i++) {
1595 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1596 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1597 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1598 &vc1_ac_tables[i][0][1], 8, 4,
1599 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1600 /* initialize interlaced MVDATA tables (2-Ref) */
1601 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1602 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1603 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1604 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1605 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1607 for (i = 0; i < 4; i++) {
1608 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1609 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1610 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1611 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1612 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1613 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1614 /* initialize NON-4MV MBMODE VLC tables for the same */
1615 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1616 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1617 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1618 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1619 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1620 /* initialize interlaced MVDATA tables (1-Ref) */
1621 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1622 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1623 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1624 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1625 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1627 for (i = 0; i < 4; i++) {
1628 /* Initialize 2MV Block pattern VLC tables */
1629 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1630 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1631 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1632 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1633 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1635 for (i = 0; i < 8; i++) {
1636 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1637 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1638 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1639 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1640 ff_vc1_icbpcy_p_bits[i], 1, 1,
1641 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1642 /* Initialize interlaced field picture MBMODE VLC tables */
1643 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1644 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1645 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1646 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1647 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1648 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1649 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1650 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1651 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1652 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1657 /* Other defaults */
1659 v->mvrange = 0; /* 7.1.1.18, p80 */