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 Libav.
9 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder common code
30 #include "libavutil/attributes.h"
33 #include "mpegvideo.h"
36 #include "msmpeg4data.h"
38 #include "simple_idct.h"
43 /***********************************************************************/
45 * @name VC-1 Bitplane decoding
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(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 v->s.avctx->width = v->s.avctx->coded_width = get_bits(gb, 11);
384 v->s.avctx->height = v->s.avctx->coded_height = get_bits(gb, 11);
385 skip_bits(gb, 5); //frame rate
386 v->res_x8 = get_bits1(gb);
387 if (get_bits1(gb)) { // something to do with DC VLC selection
388 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
391 skip_bits(gb, 3); //slice code
394 v->res_rtm_flag = get_bits1(gb); //reserved
396 if (!v->res_rtm_flag) {
397 av_log(avctx, AV_LOG_ERROR,
398 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
401 //TODO: figure out what they mean (always 0x402F)
404 av_log(avctx, AV_LOG_DEBUG,
405 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
406 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
407 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
408 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
409 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
410 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
411 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
412 v->dquant, v->quantizer_mode, avctx->max_b_frames);
416 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
419 v->level = get_bits(gb, 3);
421 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
423 v->chromaformat = get_bits(gb, 2);
424 if (v->chromaformat != 1) {
425 av_log(v->s.avctx, AV_LOG_ERROR,
426 "Only 4:2:0 chroma format supported\n");
431 v->frmrtq_postproc = get_bits(gb, 3); //common
432 // (bitrate-32kbps)/64kbps
433 v->bitrtq_postproc = get_bits(gb, 5); //common
434 v->postprocflag = get_bits1(gb); //common
436 v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
437 v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
438 v->s.avctx->width = v->s.avctx->coded_width;
439 v->s.avctx->height = v->s.avctx->coded_height;
440 v->broadcast = get_bits1(gb);
441 v->interlace = get_bits1(gb);
442 v->tfcntrflag = get_bits1(gb);
443 v->finterpflag = get_bits1(gb);
444 skip_bits1(gb); // reserved
446 av_log(v->s.avctx, AV_LOG_DEBUG,
447 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
448 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
449 "TFCTRflag=%i, FINTERPflag=%i\n",
450 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
451 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
452 v->tfcntrflag, v->finterpflag);
454 v->psf = get_bits1(gb);
455 if (v->psf) { //PsF, 6.1.13
456 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
459 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
460 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
462 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
463 w = get_bits(gb, 14) + 1;
464 h = get_bits(gb, 14) + 1;
465 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
467 ar = get_bits(gb, 4);
469 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
470 } else if (ar == 15) {
471 w = get_bits(gb, 8) + 1;
472 h = get_bits(gb, 8) + 1;
473 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
475 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
476 &v->s.avctx->sample_aspect_ratio.den,
477 v->s.avctx->height * w,
478 v->s.avctx->width * h,
481 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
482 v->s.avctx->sample_aspect_ratio.num,
483 v->s.avctx->sample_aspect_ratio.den);
485 if (get_bits1(gb)) { //framerate stuff
487 v->s.avctx->time_base.num = 32;
488 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
491 nr = get_bits(gb, 8);
492 dr = get_bits(gb, 4);
493 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
494 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
495 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
498 if (v->broadcast) { // Pulldown may be present
499 v->s.avctx->time_base.den *= 2;
500 v->s.avctx->ticks_per_frame = 2;
505 v->color_prim = get_bits(gb, 8);
506 v->transfer_char = get_bits(gb, 8);
507 v->matrix_coef = get_bits(gb, 8);
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)
529 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
530 v->broken_link = get_bits1(gb);
531 v->closed_entry = get_bits1(gb);
532 v->panscanflag = get_bits1(gb);
533 v->refdist_flag = get_bits1(gb);
534 v->s.loop_filter = get_bits1(gb);
535 v->fastuvmc = get_bits1(gb);
536 v->extended_mv = get_bits1(gb);
537 v->dquant = get_bits(gb, 2);
538 v->vstransform = get_bits1(gb);
539 v->overlap = get_bits1(gb);
540 v->quantizer_mode = get_bits(gb, 2);
542 if (v->hrd_param_flag) {
543 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
544 skip_bits(gb, 8); //hrd_full[n]
549 avctx->width = avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
550 avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
553 v->extended_dmv = get_bits1(gb);
554 if ((v->range_mapy_flag = get_bits1(gb))) {
555 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
556 v->range_mapy = get_bits(gb, 3);
558 if ((v->range_mapuv_flag = get_bits1(gb))) {
559 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
560 v->range_mapuv = get_bits(gb, 3);
563 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
564 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
565 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
566 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
567 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
568 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
573 /* fill lookup tables for intensity compensation */
574 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \
575 int scale, shift, i; \
578 shift = (255 - lumshift * 2) << 6; \
582 scale = lumscale + 32; \
584 shift = (lumshift - 64) << 6; \
586 shift = lumshift << 6; \
588 for (i = 0; i < 256; i++) { \
589 int iy = chain ? luty[i] : i; \
590 int iu = chain ? lutuv[i] : i; \
591 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
592 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
596 static void rotate_luts(VC1Context *v)
598 #define ROTATE(DEF, L, N, C, A) do { \
599 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
603 memcpy(&tmp, &L , sizeof(tmp)); \
604 memcpy(&L , &N , sizeof(tmp)); \
605 memcpy(&N , &tmp, sizeof(tmp)); \
610 ROTATE(int tmp, v->last_use_ic, v->next_use_ic, v->curr_use_ic, v->aux_use_ic);
611 ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
612 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
614 INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
615 INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
619 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
621 int pqindex, lowquant, status;
624 v->interpfrm = get_bits1(gb);
625 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
628 v->multires = get_bits(gb, 2) == 1;
630 skip_bits(gb, 2); //framecnt unused
633 v->rangeredfrm = get_bits1(gb);
634 v->s.pict_type = get_bits1(gb);
635 if (v->s.avctx->max_b_frames) {
636 if (!v->s.pict_type) {
638 v->s.pict_type = AV_PICTURE_TYPE_I;
640 v->s.pict_type = AV_PICTURE_TYPE_B;
642 v->s.pict_type = AV_PICTURE_TYPE_P;
644 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
647 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
648 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
649 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
650 if (v->bfraction == 0) {
651 v->s.pict_type = AV_PICTURE_TYPE_BI;
654 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
655 skip_bits(gb, 7); // skip buffer fullness
661 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
663 if (v->s.pict_type == AV_PICTURE_TYPE_P)
666 /* Quantizer stuff */
667 pqindex = get_bits(gb, 5);
670 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
671 v->pq = ff_vc1_pquant_table[0][pqindex];
673 v->pq = ff_vc1_pquant_table[1][pqindex];
676 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
677 v->pquantizer = pqindex < 9;
678 if (v->quantizer_mode == QUANT_NON_UNIFORM)
680 v->pqindex = pqindex;
682 v->halfpq = get_bits1(gb);
685 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
686 v->pquantizer = get_bits1(gb);
688 if (v->extended_mv == 1)
689 v->mvrange = get_unary(gb, 0, 3);
690 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
691 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
692 v->range_x = 1 << (v->k_x - 1);
693 v->range_y = 1 << (v->k_y - 1);
694 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
695 v->respic = get_bits(gb, 2);
697 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
698 v->x8_type = get_bits1(gb);
701 av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
702 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
703 pqindex, v->pq, v->halfpq, v->rangeredfrm);
705 if (v->first_pic_header_flag)
708 switch (v->s.pict_type) {
709 case AV_PICTURE_TYPE_P:
710 if (v->pq < 5) v->tt_index = 0;
711 else if (v->pq < 13) v->tt_index = 1;
712 else v->tt_index = 2;
714 lowquant = (v->pq > 12) ? 0 : 1;
715 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
716 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
717 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
718 v->lumscale = get_bits(gb, 6);
719 v->lumshift = get_bits(gb, 6);
721 /* fill lookup tables for intensity compensation */
722 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
723 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
725 v->qs_last = v->s.quarter_sample;
726 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
727 v->s.quarter_sample = 0;
728 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
729 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
730 v->s.quarter_sample = 0;
732 v->s.quarter_sample = 1;
734 v->s.quarter_sample = 1;
735 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));
737 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
738 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
739 v->mv_mode == MV_PMODE_MIXED_MV) {
740 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
743 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
744 "Imode: %i, Invert: %i\n", status>>1, status&1);
746 v->mv_type_is_raw = 0;
747 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
749 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
752 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
753 "Imode: %i, Invert: %i\n", status>>1, status&1);
755 /* Hopefully this is correct for P frames */
756 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
757 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
760 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
761 vop_dquant_decoding(v);
764 v->ttfrm = 0; //FIXME Is that so ?
765 if (v->vstransform) {
766 v->ttmbf = get_bits1(gb);
768 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
775 case AV_PICTURE_TYPE_B:
776 if (v->pq < 5) v->tt_index = 0;
777 else if (v->pq < 13) v->tt_index = 1;
778 else v->tt_index = 2;
780 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
781 v->qs_last = v->s.quarter_sample;
782 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
783 v->s.mspel = v->s.quarter_sample;
785 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
788 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
789 "Imode: %i, Invert: %i\n", status>>1, status&1);
790 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
793 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
794 "Imode: %i, Invert: %i\n", status>>1, status&1);
796 v->s.mv_table_index = get_bits(gb, 2);
797 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
800 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
801 vop_dquant_decoding(v);
805 if (v->vstransform) {
806 v->ttmbf = get_bits1(gb);
808 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
819 v->c_ac_table_index = decode012(gb);
820 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
821 v->y_ac_table_index = decode012(gb);
824 v->s.dc_table_index = get_bits1(gb);
827 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
828 v->s.pict_type = AV_PICTURE_TYPE_B;
834 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
836 int pqindex, lowquant;
838 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
841 v->p_frame_skipped = 0;
842 if (v->second_field) {
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;
855 if (fcm == ILACE_FIELD)
861 if (!v->first_pic_header_flag && v->field_mode != field_mode)
862 return AVERROR_INVALIDDATA;
863 v->field_mode = field_mode;
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 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
905 if (v->p_frame_skipped) {
908 v->rnd = get_bits1(gb);
910 v->uvsamp = get_bits1(gb);
912 if (!v->refdist_flag)
914 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
915 v->refdist = get_bits(gb, 2);
917 v->refdist += get_unary(gb, 0, 16);
919 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
920 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
921 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
922 v->frfd = (v->bfraction * v->refdist) >> 8;
923 v->brfd = v->refdist - v->frfd - 1;
927 goto parse_common_info;
929 if (v->fcm == PROGRESSIVE) {
931 v->interpfrm = get_bits1(gb);
932 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
933 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
934 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
935 if (v->bfraction == 0) {
936 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
943 v->cur_field_type = !(v->tff ^ v->second_field);
944 pqindex = get_bits(gb, 5);
947 v->pqindex = pqindex;
948 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
949 v->pq = ff_vc1_pquant_table[0][pqindex];
951 v->pq = ff_vc1_pquant_table[1][pqindex];
954 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
955 v->pquantizer = pqindex < 9;
956 if (v->quantizer_mode == QUANT_NON_UNIFORM)
958 v->pqindex = pqindex;
960 v->halfpq = get_bits1(gb);
963 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
964 v->pquantizer = get_bits1(gb);
966 v->postproc = get_bits(gb, 2);
971 if (v->first_pic_header_flag)
974 switch (v->s.pict_type) {
975 case AV_PICTURE_TYPE_I:
976 case AV_PICTURE_TYPE_BI:
977 if (v->fcm == ILACE_FRAME) { //interlace frame picture
978 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
981 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
982 "Imode: %i, Invert: %i\n", status>>1, status&1);
984 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
987 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
988 "Imode: %i, Invert: %i\n", status>>1, status&1);
989 v->condover = CONDOVER_NONE;
990 if (v->overlap && v->pq <= 8) {
991 v->condover = decode012(gb);
992 if (v->condover == CONDOVER_SELECT) {
993 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
996 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
997 "Imode: %i, Invert: %i\n", status>>1, status&1);
1001 case AV_PICTURE_TYPE_P:
1002 if (v->field_mode) {
1003 v->numref = get_bits1(gb);
1005 v->reffield = get_bits1(gb);
1006 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1010 v->mvrange = get_unary(gb, 0, 3);
1014 if (v->extended_dmv)
1015 v->dmvrange = get_unary(gb, 0, 3);
1018 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1019 v->fourmvswitch = get_bits1(gb);
1020 v->intcomp = get_bits1(gb);
1022 v->lumscale = get_bits(gb, 6);
1023 v->lumshift = get_bits(gb, 6);
1024 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1025 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
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];
1069 if (v->field_mode) {
1070 v->intcompfield = decode210(gb) ^ 3;
1072 v->intcompfield = 3;
1074 v->lumscale2 = v->lumscale = 32;
1075 v->lumshift2 = v->lumshift = 0;
1076 if (v->intcompfield & 1) {
1077 v->lumscale = get_bits(gb, 6);
1078 v->lumshift = get_bits(gb, 6);
1080 if ((v->intcompfield & 2) && v->field_mode) {
1081 v->lumscale2 = get_bits(gb, 6);
1082 v->lumshift2 = get_bits(gb, 6);
1083 } else if(!v->field_mode) {
1084 v->lumscale2 = v->lumscale;
1085 v->lumshift2 = v->lumshift;
1087 if (v->field_mode && v->second_field) {
1088 if (v->cur_field_type) {
1089 INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1090 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1092 INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1093 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1095 v->next_use_ic = v->curr_use_ic = 1;
1097 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1098 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1102 v->qs_last = v->s.quarter_sample;
1103 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1104 v->s.quarter_sample = 0;
1105 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1106 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1107 v->s.quarter_sample = 0;
1109 v->s.quarter_sample = 1;
1111 v->s.quarter_sample = 1;
1112 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1113 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1114 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1116 if (v->fcm == PROGRESSIVE) { // progressive
1117 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1118 v->mv_mode2 == MV_PMODE_MIXED_MV)
1119 || v->mv_mode == MV_PMODE_MIXED_MV) {
1120 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1123 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1124 "Imode: %i, Invert: %i\n", status>>1, status&1);
1126 v->mv_type_is_raw = 0;
1127 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1129 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1132 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1133 "Imode: %i, Invert: %i\n", status>>1, status&1);
1135 /* Hopefully this is correct for P frames */
1136 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1137 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1138 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1139 v->qs_last = v->s.quarter_sample;
1140 v->s.quarter_sample = 1;
1142 } else { // field interlaced
1143 mbmodetab = get_bits(gb, 3);
1144 imvtab = get_bits(gb, 2 + v->numref);
1146 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1148 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1149 icbptab = get_bits(gb, 3);
1150 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1151 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1152 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1153 fourmvbptab = get_bits(gb, 2);
1154 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1155 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1157 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1161 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1162 vop_dquant_decoding(v);
1165 v->ttfrm = 0; //FIXME Is that so ?
1166 if (v->vstransform) {
1167 v->ttmbf = get_bits1(gb);
1169 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1176 case AV_PICTURE_TYPE_B:
1177 if (v->fcm == ILACE_FRAME) {
1178 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1179 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1180 if (v->bfraction == 0) {
1183 return -1; // This codepath is still incomplete thus it is disabled
1186 v->mvrange = get_unary(gb, 0, 3);
1189 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1190 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1191 v->range_x = 1 << (v->k_x - 1);
1192 v->range_y = 1 << (v->k_y - 1);
1196 else if (v->pq < 13)
1201 if (v->field_mode) {
1203 if (v->extended_dmv)
1204 v->dmvrange = get_unary(gb, 0, 3);
1205 mvmode = get_unary(gb, 1, 3);
1206 lowquant = (v->pq > 12) ? 0 : 1;
1207 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1208 v->qs_last = v->s.quarter_sample;
1209 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1210 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1211 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1214 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1215 "Imode: %i, Invert: %i\n", status>>1, status&1);
1216 mbmodetab = get_bits(gb, 3);
1217 if (v->mv_mode == MV_PMODE_MIXED_MV)
1218 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1220 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1221 imvtab = get_bits(gb, 3);
1222 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1223 icbptab = get_bits(gb, 3);
1224 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1225 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1226 fourmvbptab = get_bits(gb, 2);
1227 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1229 v->numref = 1; // interlaced field B pictures are always 2-ref
1230 } else if (v->fcm == ILACE_FRAME) {
1231 if (v->extended_dmv)
1232 v->dmvrange = get_unary(gb, 0, 3);
1233 if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1234 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1236 v->mv_mode = MV_PMODE_1MV;
1237 v->fourmvswitch = 0;
1238 v->qs_last = v->s.quarter_sample;
1239 v->s.quarter_sample = 1;
1241 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1244 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1245 "Imode: %i, Invert: %i\n", status>>1, status&1);
1246 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1249 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1250 "Imode: %i, Invert: %i\n", status>>1, status&1);
1251 mbmodetab = get_bits(gb, 2);
1252 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1253 imvtab = get_bits(gb, 2);
1254 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1255 // interlaced p/b-picture cbpcy range is [1, 63]
1256 icbptab = get_bits(gb, 3);
1257 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1258 twomvbptab = get_bits(gb, 2);
1259 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1260 fourmvbptab = get_bits(gb, 2);
1261 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1263 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1264 v->qs_last = v->s.quarter_sample;
1265 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1266 v->s.mspel = v->s.quarter_sample;
1267 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1270 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1271 "Imode: %i, Invert: %i\n", status>>1, status&1);
1272 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1275 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1276 "Imode: %i, Invert: %i\n", status>>1, status&1);
1277 v->s.mv_table_index = get_bits(gb, 2);
1278 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1282 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1283 vop_dquant_decoding(v);
1287 if (v->vstransform) {
1288 v->ttmbf = get_bits1(gb);
1290 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1299 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1305 v->c_ac_table_index = decode012(gb);
1306 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1307 v->y_ac_table_index = decode012(gb);
1310 v->s.dc_table_index = get_bits1(gb);
1311 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1313 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1314 vop_dquant_decoding(v);
1318 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1319 v->s.pict_type = AV_PICTURE_TYPE_B;
1325 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1327 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1328 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1329 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1330 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1331 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1332 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1333 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1334 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1335 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1336 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1337 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1338 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1339 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1340 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1341 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1342 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1343 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1344 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1345 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1346 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1347 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1348 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1349 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1350 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1351 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1352 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1353 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1354 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1355 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1356 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1357 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1360 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1361 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1362 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1363 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1364 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1365 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1366 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1367 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1368 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1369 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1370 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1371 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1372 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1373 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1374 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1375 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1376 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1377 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1378 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1379 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1380 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1381 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1382 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1383 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1384 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1385 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1386 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1387 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1391 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1392 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1393 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1394 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1395 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1396 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1397 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1398 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1399 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1400 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1401 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1402 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1403 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1404 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1405 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1406 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1407 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1408 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1409 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1410 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1411 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1412 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1416 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1417 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1418 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1419 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1420 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1421 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1422 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1423 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1424 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1425 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1426 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1427 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1428 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1429 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1430 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1431 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1432 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1433 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1434 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1435 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1436 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1437 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1438 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1439 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1440 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1443 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1444 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1445 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1446 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1447 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1448 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1449 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1450 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1451 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1452 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1453 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1454 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1455 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1456 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1457 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1458 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1459 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1463 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1464 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1465 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1466 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1467 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1468 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1469 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1470 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1471 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1472 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1473 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1474 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1475 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1476 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1477 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1478 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1479 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1483 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1484 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1485 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1486 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1487 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1488 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1489 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1490 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1491 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1492 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1493 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1494 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1495 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1496 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1497 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1498 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1499 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1500 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1501 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1502 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1503 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1504 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1505 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1506 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1507 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1508 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1509 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1513 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1514 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1515 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1516 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1517 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1518 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1519 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1520 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1521 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1522 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1523 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1524 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1525 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1526 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1527 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1528 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1529 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1530 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1531 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1532 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1533 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1534 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1535 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1536 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1537 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1538 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1539 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1540 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1541 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1546 static const uint16_t vlc_offs[] = {
1547 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1548 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1549 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1550 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1551 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1552 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1553 31714, 31746, 31778, 32306, 32340, 32372
1557 * Init VC-1 specific tables and VC1Context members
1558 * @param v The VC1Context to initialize
1561 av_cold int ff_vc1_init_common(VC1Context *v)
1563 static int done = 0;
1565 static VLC_TYPE vlc_table[32372][2];
1567 v->hrd_rate = v->hrd_buffer = NULL;
1571 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1572 ff_vc1_bfraction_bits, 1, 1,
1573 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1574 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1575 ff_vc1_norm2_bits, 1, 1,
1576 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1577 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1578 ff_vc1_norm6_bits, 1, 1,
1579 ff_vc1_norm6_codes, 2, 2, 556);
1580 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1581 ff_vc1_imode_bits, 1, 1,
1582 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1583 for (i = 0; i < 3; i++) {
1584 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1585 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1586 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1587 ff_vc1_ttmb_bits[i], 1, 1,
1588 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1589 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1590 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1591 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1592 ff_vc1_ttblk_bits[i], 1, 1,
1593 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1594 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1595 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1596 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1597 ff_vc1_subblkpat_bits[i], 1, 1,
1598 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1600 for (i = 0; i < 4; i++) {
1601 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1602 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1603 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1604 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1605 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1606 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1607 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1608 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1609 ff_vc1_cbpcy_p_bits[i], 1, 1,
1610 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1611 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1612 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1613 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1614 ff_vc1_mv_diff_bits[i], 1, 1,
1615 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1617 for (i = 0; i < 8; i++) {
1618 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1619 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1620 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1621 &vc1_ac_tables[i][0][1], 8, 4,
1622 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1623 /* initialize interlaced MVDATA tables (2-Ref) */
1624 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1625 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1626 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1627 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1628 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1630 for (i = 0; i < 4; i++) {
1631 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1632 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1633 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1634 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1635 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1636 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1637 /* initialize NON-4MV MBMODE VLC tables for the same */
1638 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1639 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1640 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1641 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1642 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1643 /* initialize interlaced MVDATA tables (1-Ref) */
1644 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1645 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1646 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1647 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1648 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1650 for (i = 0; i < 4; i++) {
1651 /* Initialize 2MV Block pattern VLC tables */
1652 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1653 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1654 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1655 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1656 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1658 for (i = 0; i < 8; i++) {
1659 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1660 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1661 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1662 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1663 ff_vc1_icbpcy_p_bits[i], 1, 1,
1664 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1665 /* Initialize interlaced field picture MBMODE VLC tables */
1666 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1667 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1668 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1669 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1670 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1671 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1672 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1673 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1674 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1675 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1680 /* Other defaults */
1682 v->mvrange = 0; /* 7.1.1.18, p80 */