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->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->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 ff_set_sar(v->s.avctx, v->s.avctx->sample_aspect_ratio);
482 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
483 v->s.avctx->sample_aspect_ratio.num,
484 v->s.avctx->sample_aspect_ratio.den);
486 if (get_bits1(gb)) { //framerate stuff
488 v->s.avctx->framerate.den = 32;
489 v->s.avctx->framerate.num = get_bits(gb, 16) + 1;
492 nr = get_bits(gb, 8);
493 dr = get_bits(gb, 4);
494 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
495 v->s.avctx->framerate.den = ff_vc1_fps_dr[dr - 1];
496 v->s.avctx->framerate.num = ff_vc1_fps_nr[nr - 1] * 1000;
499 if (v->broadcast) { // Pulldown may be present
500 v->s.avctx->framerate.num *= 2;
501 v->s.avctx->ticks_per_frame = 2;
506 v->color_prim = get_bits(gb, 8);
507 v->transfer_char = get_bits(gb, 8);
508 v->matrix_coef = get_bits(gb, 8);
512 v->hrd_param_flag = get_bits1(gb);
513 if (v->hrd_param_flag) {
515 v->hrd_num_leaky_buckets = get_bits(gb, 5);
516 skip_bits(gb, 4); //bitrate exponent
517 skip_bits(gb, 4); //buffer size exponent
518 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
519 skip_bits(gb, 16); //hrd_rate[n]
520 skip_bits(gb, 16); //hrd_buffer[n]
526 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 v->fastuvmc = get_bits1(gb);
537 v->extended_mv = get_bits1(gb);
538 v->dquant = get_bits(gb, 2);
539 v->vstransform = get_bits1(gb);
540 v->overlap = get_bits1(gb);
541 v->quantizer_mode = get_bits(gb, 2);
543 if (v->hrd_param_flag) {
544 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
545 skip_bits(gb, 8); //hrd_full[n]
550 avctx->width = avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
551 avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
554 v->extended_dmv = get_bits1(gb);
555 if ((v->range_mapy_flag = get_bits1(gb))) {
556 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
557 v->range_mapy = get_bits(gb, 3);
559 if ((v->range_mapuv_flag = get_bits1(gb))) {
560 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
561 v->range_mapuv = get_bits(gb, 3);
564 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
565 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
566 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
567 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
568 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
569 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
574 /* fill lookup tables for intensity compensation */
575 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \
576 int scale, shift, i; \
579 shift = (255 - lumshift * 2) << 6; \
583 scale = lumscale + 32; \
585 shift = (lumshift - 64) << 6; \
587 shift = lumshift << 6; \
589 for (i = 0; i < 256; i++) { \
590 int iy = chain ? luty[i] : i; \
591 int iu = chain ? lutuv[i] : i; \
592 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
593 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
597 static void rotate_luts(VC1Context *v)
599 #define ROTATE(DEF, L, N, C, A) do { \
600 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
604 memcpy(&tmp, &L , sizeof(tmp)); \
605 memcpy(&L , &N , sizeof(tmp)); \
606 memcpy(&N , &tmp, sizeof(tmp)); \
611 ROTATE(int tmp, v->last_use_ic, v->next_use_ic, v->curr_use_ic, v->aux_use_ic);
612 ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
613 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
615 INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
616 INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
618 if (v->curr_luty == v->next_luty) {
619 // If we just initialized next_lut, clear next_use_ic to match.
624 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
626 int pqindex, lowquant, status;
629 v->interpfrm = get_bits1(gb);
630 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
633 v->multires = get_bits(gb, 2) == 1;
635 skip_bits(gb, 2); //framecnt unused
638 v->rangeredfrm = get_bits1(gb);
639 v->s.pict_type = get_bits1(gb);
640 if (v->s.avctx->max_b_frames) {
641 if (!v->s.pict_type) {
643 v->s.pict_type = AV_PICTURE_TYPE_I;
645 v->s.pict_type = AV_PICTURE_TYPE_B;
647 v->s.pict_type = AV_PICTURE_TYPE_P;
649 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
652 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
653 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
654 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
655 if (v->bfraction == 0) {
656 v->s.pict_type = AV_PICTURE_TYPE_BI;
659 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
660 skip_bits(gb, 7); // skip buffer fullness
666 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
668 if (v->s.pict_type == AV_PICTURE_TYPE_P)
671 /* Quantizer stuff */
672 pqindex = get_bits(gb, 5);
675 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
676 v->pq = ff_vc1_pquant_table[0][pqindex];
678 v->pq = ff_vc1_pquant_table[1][pqindex];
681 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
682 v->pquantizer = pqindex < 9;
683 if (v->quantizer_mode == QUANT_NON_UNIFORM)
685 v->pqindex = pqindex;
687 v->halfpq = get_bits1(gb);
690 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
691 v->pquantizer = get_bits1(gb);
693 if (v->extended_mv == 1)
694 v->mvrange = get_unary(gb, 0, 3);
695 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
696 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
697 v->range_x = 1 << (v->k_x - 1);
698 v->range_y = 1 << (v->k_y - 1);
699 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
700 v->respic = get_bits(gb, 2);
702 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
703 v->x8_type = get_bits1(gb);
706 av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
707 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
708 pqindex, v->pq, v->halfpq, v->rangeredfrm);
710 if (v->first_pic_header_flag)
713 switch (v->s.pict_type) {
714 case AV_PICTURE_TYPE_P:
715 if (v->pq < 5) v->tt_index = 0;
716 else if (v->pq < 13) v->tt_index = 1;
717 else v->tt_index = 2;
719 lowquant = (v->pq > 12) ? 0 : 1;
720 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
721 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
722 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
723 v->lumscale = get_bits(gb, 6);
724 v->lumshift = get_bits(gb, 6);
726 /* fill lookup tables for intensity compensation */
727 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
728 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
730 v->qs_last = v->s.quarter_sample;
731 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
732 v->s.quarter_sample = 0;
733 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
734 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
735 v->s.quarter_sample = 0;
737 v->s.quarter_sample = 1;
739 v->s.quarter_sample = 1;
740 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));
742 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
743 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
744 v->mv_mode == MV_PMODE_MIXED_MV) {
745 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
748 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
749 "Imode: %i, Invert: %i\n", status>>1, status&1);
751 v->mv_type_is_raw = 0;
752 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
754 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
757 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
758 "Imode: %i, Invert: %i\n", status>>1, status&1);
760 /* Hopefully this is correct for P frames */
761 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
762 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
765 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
766 vop_dquant_decoding(v);
769 v->ttfrm = 0; //FIXME Is that so ?
770 if (v->vstransform) {
771 v->ttmbf = get_bits1(gb);
773 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
780 case AV_PICTURE_TYPE_B:
781 if (v->pq < 5) v->tt_index = 0;
782 else if (v->pq < 13) v->tt_index = 1;
783 else v->tt_index = 2;
785 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
786 v->qs_last = v->s.quarter_sample;
787 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
788 v->s.mspel = v->s.quarter_sample;
790 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
793 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
794 "Imode: %i, Invert: %i\n", status>>1, status&1);
795 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
798 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
799 "Imode: %i, Invert: %i\n", status>>1, status&1);
801 v->s.mv_table_index = get_bits(gb, 2);
802 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
805 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
806 vop_dquant_decoding(v);
810 if (v->vstransform) {
811 v->ttmbf = get_bits1(gb);
813 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
824 v->c_ac_table_index = decode012(gb);
825 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
826 v->y_ac_table_index = decode012(gb);
829 v->s.dc_table_index = get_bits1(gb);
832 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
833 v->s.pict_type = AV_PICTURE_TYPE_B;
839 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
841 int pqindex, lowquant;
843 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
847 v->p_frame_skipped = 0;
848 if (v->second_field) {
849 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
851 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
852 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
853 if (!v->pic_header_flag)
854 goto parse_common_info;
861 if (fcm == ILACE_FIELD)
867 if (!v->first_pic_header_flag && v->field_mode != field_mode)
868 return AVERROR_INVALIDDATA;
869 v->field_mode = field_mode;
873 v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
874 v->fptype = get_bits(gb, 3);
875 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
876 if (v->fptype & 4) // B-picture
877 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
879 v->s.mb_height = v->s.height + 15 >> 4;
880 switch (get_unary(gb, 0, 4)) {
882 v->s.pict_type = AV_PICTURE_TYPE_P;
885 v->s.pict_type = AV_PICTURE_TYPE_B;
888 v->s.pict_type = AV_PICTURE_TYPE_I;
891 v->s.pict_type = AV_PICTURE_TYPE_BI;
894 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
895 v->p_frame_skipped = 1;
902 if (!v->interlace || v->psf) {
903 v->rptfrm = get_bits(gb, 2);
905 v->tff = get_bits1(gb);
906 v->rff = get_bits1(gb);
909 if (v->panscanflag) {
910 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
913 if (v->p_frame_skipped) {
916 v->rnd = get_bits1(gb);
918 v->uvsamp = get_bits1(gb);
920 if (!v->refdist_flag)
922 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
923 v->refdist = get_bits(gb, 2);
925 v->refdist += get_unary(gb, 0, 16);
927 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
928 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
929 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
930 v->frfd = (v->bfraction * v->refdist) >> 8;
931 v->brfd = v->refdist - v->frfd - 1;
935 goto parse_common_info;
937 if (v->fcm == PROGRESSIVE) {
939 v->interpfrm = get_bits1(gb);
940 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
941 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
942 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
943 if (v->bfraction == 0) {
944 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
951 v->cur_field_type = !(v->tff ^ v->second_field);
952 pqindex = get_bits(gb, 5);
955 v->pqindex = pqindex;
956 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
957 v->pq = ff_vc1_pquant_table[0][pqindex];
959 v->pq = ff_vc1_pquant_table[1][pqindex];
962 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
963 v->pquantizer = pqindex < 9;
964 if (v->quantizer_mode == QUANT_NON_UNIFORM)
966 v->pqindex = pqindex;
968 v->halfpq = get_bits1(gb);
971 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
972 v->pquantizer = get_bits1(gb);
974 v->postproc = get_bits(gb, 2);
979 if (v->first_pic_header_flag)
982 switch (v->s.pict_type) {
983 case AV_PICTURE_TYPE_I:
984 case AV_PICTURE_TYPE_BI:
985 if (v->fcm == ILACE_FRAME) { //interlace frame picture
986 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
989 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
990 "Imode: %i, Invert: %i\n", status>>1, status&1);
992 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
995 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
996 "Imode: %i, Invert: %i\n", status>>1, status&1);
997 v->condover = CONDOVER_NONE;
998 if (v->overlap && v->pq <= 8) {
999 v->condover = decode012(gb);
1000 if (v->condover == CONDOVER_SELECT) {
1001 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1004 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1005 "Imode: %i, Invert: %i\n", status>>1, status&1);
1009 case AV_PICTURE_TYPE_P:
1010 if (v->field_mode) {
1011 v->numref = get_bits1(gb);
1013 v->reffield = get_bits1(gb);
1014 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1018 v->mvrange = get_unary(gb, 0, 3);
1022 if (v->extended_dmv)
1023 v->dmvrange = get_unary(gb, 0, 3);
1026 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1027 v->fourmvswitch = get_bits1(gb);
1028 v->intcomp = get_bits1(gb);
1030 v->lumscale = get_bits(gb, 6);
1031 v->lumshift = get_bits(gb, 6);
1032 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1033 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1036 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1037 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1038 "Imode: %i, Invert: %i\n", status>>1, status&1);
1039 mbmodetab = get_bits(gb, 2);
1040 if (v->fourmvswitch)
1041 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1043 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1044 imvtab = get_bits(gb, 2);
1045 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1046 // interlaced p-picture cbpcy range is [1, 63]
1047 icbptab = get_bits(gb, 3);
1048 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1049 twomvbptab = get_bits(gb, 2);
1050 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1051 if (v->fourmvswitch) {
1052 fourmvbptab = get_bits(gb, 2);
1053 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1057 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1058 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1059 v->range_x = 1 << (v->k_x - 1);
1060 v->range_y = 1 << (v->k_y - 1);
1064 else if (v->pq < 13)
1068 if (v->fcm != ILACE_FRAME) {
1070 mvmode = get_unary(gb, 1, 4);
1071 lowquant = (v->pq > 12) ? 0 : 1;
1072 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1073 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1075 mvmode2 = get_unary(gb, 1, 3);
1076 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1077 if (v->field_mode) {
1078 v->intcompfield = decode210(gb) ^ 3;
1080 v->intcompfield = 3;
1082 v->lumscale2 = v->lumscale = 32;
1083 v->lumshift2 = v->lumshift = 0;
1084 if (v->intcompfield & 1) {
1085 v->lumscale = get_bits(gb, 6);
1086 v->lumshift = get_bits(gb, 6);
1088 if ((v->intcompfield & 2) && v->field_mode) {
1089 v->lumscale2 = get_bits(gb, 6);
1090 v->lumshift2 = get_bits(gb, 6);
1091 } else if(!v->field_mode) {
1092 v->lumscale2 = v->lumscale;
1093 v->lumshift2 = v->lumshift;
1095 if (v->field_mode && v->second_field) {
1096 if (v->cur_field_type) {
1097 INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1098 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1100 INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1101 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1103 v->next_use_ic = v->curr_use_ic = 1;
1105 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1106 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1110 v->qs_last = v->s.quarter_sample;
1111 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1112 v->s.quarter_sample = 0;
1113 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1114 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1115 v->s.quarter_sample = 0;
1117 v->s.quarter_sample = 1;
1119 v->s.quarter_sample = 1;
1120 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1121 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1122 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1124 if (v->fcm == PROGRESSIVE) { // progressive
1125 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1126 v->mv_mode2 == MV_PMODE_MIXED_MV)
1127 || v->mv_mode == MV_PMODE_MIXED_MV) {
1128 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1131 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1132 "Imode: %i, Invert: %i\n", status>>1, status&1);
1134 v->mv_type_is_raw = 0;
1135 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1137 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1140 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1141 "Imode: %i, Invert: %i\n", status>>1, status&1);
1143 /* Hopefully this is correct for P frames */
1144 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1145 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1146 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1147 v->qs_last = v->s.quarter_sample;
1148 v->s.quarter_sample = 1;
1150 } else { // field interlaced
1151 mbmodetab = get_bits(gb, 3);
1152 imvtab = get_bits(gb, 2 + v->numref);
1154 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1156 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1157 icbptab = get_bits(gb, 3);
1158 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1159 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1160 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1161 fourmvbptab = get_bits(gb, 2);
1162 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1163 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1165 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1169 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1170 vop_dquant_decoding(v);
1173 v->ttfrm = 0; //FIXME Is that so ?
1174 if (v->vstransform) {
1175 v->ttmbf = get_bits1(gb);
1177 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1184 case AV_PICTURE_TYPE_B:
1185 if (v->fcm == ILACE_FRAME) {
1186 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1187 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1188 if (v->bfraction == 0) {
1193 v->mvrange = get_unary(gb, 0, 3);
1196 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1197 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1198 v->range_x = 1 << (v->k_x - 1);
1199 v->range_y = 1 << (v->k_y - 1);
1203 else if (v->pq < 13)
1208 if (v->field_mode) {
1210 if (v->extended_dmv)
1211 v->dmvrange = get_unary(gb, 0, 3);
1212 mvmode = get_unary(gb, 1, 3);
1213 lowquant = (v->pq > 12) ? 0 : 1;
1214 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1215 v->qs_last = v->s.quarter_sample;
1216 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1217 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1218 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1221 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1222 "Imode: %i, Invert: %i\n", status>>1, status&1);
1223 mbmodetab = get_bits(gb, 3);
1224 if (v->mv_mode == MV_PMODE_MIXED_MV)
1225 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1227 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1228 imvtab = get_bits(gb, 3);
1229 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1230 icbptab = get_bits(gb, 3);
1231 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1232 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1233 fourmvbptab = get_bits(gb, 2);
1234 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1236 v->numref = 1; // interlaced field B pictures are always 2-ref
1237 } else if (v->fcm == ILACE_FRAME) {
1238 if (v->extended_dmv)
1239 v->dmvrange = get_unary(gb, 0, 3);
1240 if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1241 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1243 v->mv_mode = MV_PMODE_1MV;
1244 v->fourmvswitch = 0;
1245 v->qs_last = v->s.quarter_sample;
1246 v->s.quarter_sample = 1;
1248 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1251 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1252 "Imode: %i, Invert: %i\n", status>>1, status&1);
1253 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1256 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1257 "Imode: %i, Invert: %i\n", status>>1, status&1);
1258 mbmodetab = get_bits(gb, 2);
1259 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1260 imvtab = get_bits(gb, 2);
1261 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1262 // interlaced p/b-picture cbpcy range is [1, 63]
1263 icbptab = get_bits(gb, 3);
1264 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1265 twomvbptab = get_bits(gb, 2);
1266 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1267 fourmvbptab = get_bits(gb, 2);
1268 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1270 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1271 v->qs_last = v->s.quarter_sample;
1272 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1273 v->s.mspel = v->s.quarter_sample;
1274 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1277 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1278 "Imode: %i, Invert: %i\n", status>>1, status&1);
1279 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1282 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1283 "Imode: %i, Invert: %i\n", status>>1, status&1);
1284 v->s.mv_table_index = get_bits(gb, 2);
1285 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1289 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1290 vop_dquant_decoding(v);
1294 if (v->vstransform) {
1295 v->ttmbf = get_bits1(gb);
1297 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1306 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1312 v->c_ac_table_index = decode012(gb);
1313 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1314 v->y_ac_table_index = decode012(gb);
1317 v->s.dc_table_index = get_bits1(gb);
1318 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1320 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1321 vop_dquant_decoding(v);
1325 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1326 v->s.pict_type = AV_PICTURE_TYPE_B;
1332 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1334 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1335 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1336 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1337 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1338 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1339 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1340 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1341 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1342 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1343 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1344 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1345 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1346 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1347 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1348 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1349 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1350 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1351 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1352 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1353 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1354 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1355 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1356 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1357 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1358 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1359 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1360 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1361 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1362 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1363 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1364 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1367 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1368 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1369 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1370 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1371 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1372 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1373 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1374 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1375 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1376 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1377 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1378 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1379 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1380 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1381 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1382 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1383 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1384 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1385 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1386 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1387 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1388 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1389 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1390 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1391 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1392 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1393 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1394 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1398 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1399 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1400 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1401 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1402 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1403 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1404 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1405 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1406 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1407 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1408 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1409 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1410 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1411 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1412 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1413 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1414 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1415 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1416 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1417 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1418 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1419 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1423 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1424 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1425 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1426 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1427 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1428 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1429 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1430 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1431 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1432 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1433 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1434 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1435 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1436 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1437 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1438 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1439 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1440 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1441 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1442 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1443 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1444 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1445 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1446 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1447 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1450 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1451 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1452 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1453 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1454 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1455 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1456 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1457 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1458 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1459 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1460 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1461 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1462 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1463 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1464 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1465 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1466 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1470 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1471 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1472 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1473 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1474 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1475 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1476 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1477 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1478 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1479 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1480 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1481 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1482 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1483 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1484 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1485 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1486 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1490 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1491 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1492 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1493 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1494 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1495 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1496 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1497 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1498 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1499 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1500 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1501 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1502 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1503 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1504 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1505 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1506 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1507 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1508 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1509 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1510 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1511 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1512 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1513 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1514 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1515 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1516 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1520 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1521 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1522 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1523 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1524 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1525 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1526 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1527 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1528 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1529 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1530 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1531 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1532 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1533 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1534 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1535 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1536 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1537 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1538 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1539 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1540 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1541 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1542 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1543 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1544 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1545 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1546 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1547 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1548 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1553 static const uint16_t vlc_offs[] = {
1554 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1555 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1556 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1557 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1558 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1559 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1560 31714, 31746, 31778, 32306, 32340, 32372
1564 * Init VC-1 specific tables and VC1Context members
1565 * @param v The VC1Context to initialize
1568 av_cold int ff_vc1_init_common(VC1Context *v)
1570 static int done = 0;
1572 static VLC_TYPE vlc_table[32372][2];
1574 v->hrd_rate = v->hrd_buffer = NULL;
1578 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1579 ff_vc1_bfraction_bits, 1, 1,
1580 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1581 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1582 ff_vc1_norm2_bits, 1, 1,
1583 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1584 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1585 ff_vc1_norm6_bits, 1, 1,
1586 ff_vc1_norm6_codes, 2, 2, 556);
1587 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1588 ff_vc1_imode_bits, 1, 1,
1589 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1590 for (i = 0; i < 3; i++) {
1591 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1592 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1593 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1594 ff_vc1_ttmb_bits[i], 1, 1,
1595 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1596 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1597 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1598 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1599 ff_vc1_ttblk_bits[i], 1, 1,
1600 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1601 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1602 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1603 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1604 ff_vc1_subblkpat_bits[i], 1, 1,
1605 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1607 for (i = 0; i < 4; i++) {
1608 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1609 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1610 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1611 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1612 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1613 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1614 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1615 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1616 ff_vc1_cbpcy_p_bits[i], 1, 1,
1617 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1618 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1619 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1620 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1621 ff_vc1_mv_diff_bits[i], 1, 1,
1622 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1624 for (i = 0; i < 8; i++) {
1625 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1626 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1627 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1628 &vc1_ac_tables[i][0][1], 8, 4,
1629 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1630 /* initialize interlaced MVDATA tables (2-Ref) */
1631 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1632 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1633 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1634 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1635 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1637 for (i = 0; i < 4; i++) {
1638 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1639 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1640 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1641 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1642 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1643 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1644 /* initialize NON-4MV MBMODE VLC tables for the same */
1645 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1646 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1647 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1648 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1649 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1650 /* initialize interlaced MVDATA tables (1-Ref) */
1651 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1652 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1653 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1654 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1655 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1657 for (i = 0; i < 4; i++) {
1658 /* Initialize 2MV Block pattern VLC tables */
1659 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1660 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1661 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1662 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1663 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1665 for (i = 0; i < 8; i++) {
1666 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1667 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1668 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1669 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1670 ff_vc1_icbpcy_p_bits[i], 1, 1,
1671 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1672 /* Initialize interlaced field picture MBMODE VLC tables */
1673 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1674 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1675 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1676 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1677 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1678 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1679 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1680 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1681 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1682 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1687 /* Other defaults */
1689 v->mvrange = 0; /* 7.1.1.18, p80 */
1691 ff_vc1dsp_init(&v->vc1dsp);