2 * VC-1 and WMV3 decoder common code
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder common code
29 #include "libavutil/attributes.h"
32 #include "mpegvideo.h"
37 #include "simple_idct.h"
39 /***********************************************************************/
41 * @name VC-1 Bitplane decoding
46 /** Decode rows by checking if they are skipped
47 * @param plane Buffer to store decoded bits
48 * @param[in] width Width of this buffer
49 * @param[in] height Height of this buffer
50 * @param[in] stride of this buffer
52 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
57 for (y = 0; y < height; y++) {
58 if (!get_bits1(gb)) //rowskip
59 memset(plane, 0, width);
61 for (x = 0; x < width; x++)
62 plane[x] = get_bits1(gb);
67 /** Decode columns by checking if they are skipped
68 * @param plane Buffer to store decoded bits
69 * @param[in] width Width of this buffer
70 * @param[in] height Height of this buffer
71 * @param[in] stride of this buffer
72 * @todo FIXME: Optimize
74 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
79 for (x = 0; x < width; x++) {
80 if (!get_bits1(gb)) //colskip
81 for (y = 0; y < height; y++)
84 for (y = 0; y < height; y++)
85 plane[y*stride] = get_bits1(gb);
90 /** Decode a bitplane's bits
91 * @param data bitplane where to store the decode bits
92 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
93 * @param v VC-1 context for bit reading and logging
95 * @todo FIXME: Optimize
97 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
99 GetBitContext *gb = &v->s.gb;
101 int imode, x, y, code, offset;
102 uint8_t invert, *planep = data;
103 int width, height, stride;
105 width = v->s.mb_width;
106 height = v->s.mb_height >> v->field_mode;
107 stride = v->s.mb_stride;
108 invert = get_bits1(gb);
109 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
114 //Data is actually read in the MB layer (same for all tests == "raw")
115 *raw_flag = 1; //invert ignored
119 if ((height * width) & 1) {
120 *planep++ = get_bits1(gb);
122 if (offset == width) {
124 planep += stride - width;
129 // decode bitplane as one long line
130 for (; y < height * width; y += 2) {
131 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
132 *planep++ = code & 1;
134 if (offset == width) {
136 planep += stride - width;
138 *planep++ = code >> 1;
140 if (offset == width) {
142 planep += stride - width;
148 if (!(height % 3) && (width % 3)) { // use 2x3 decoding
149 for (y = 0; y < height; y += 3) {
150 for (x = width & 1; x < width; x += 2) {
151 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
153 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
156 planep[x + 0] = (code >> 0) & 1;
157 planep[x + 1] = (code >> 1) & 1;
158 planep[x + 0 + stride] = (code >> 2) & 1;
159 planep[x + 1 + stride] = (code >> 3) & 1;
160 planep[x + 0 + stride * 2] = (code >> 4) & 1;
161 planep[x + 1 + stride * 2] = (code >> 5) & 1;
163 planep += stride * 3;
166 decode_colskip(data, 1, height, stride, &v->s.gb);
168 planep += (height & 1) * stride;
169 for (y = height & 1; y < height; y += 2) {
170 for (x = width % 3; x < width; x += 3) {
171 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
173 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
176 planep[x + 0] = (code >> 0) & 1;
177 planep[x + 1] = (code >> 1) & 1;
178 planep[x + 2] = (code >> 2) & 1;
179 planep[x + 0 + stride] = (code >> 3) & 1;
180 planep[x + 1 + stride] = (code >> 4) & 1;
181 planep[x + 2 + stride] = (code >> 5) & 1;
183 planep += stride * 2;
187 decode_colskip(data, x, height, stride, &v->s.gb);
189 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
193 decode_rowskip(data, width, height, stride, &v->s.gb);
196 decode_colskip(data, width, height, stride, &v->s.gb);
202 /* Applying diff operator */
203 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
206 for (x = 1; x < width; x++)
207 planep[x] ^= planep[x-1];
208 for (y = 1; y < height; y++) {
210 planep[0] ^= planep[-stride];
211 for (x = 1; x < width; x++) {
212 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
213 else planep[x] ^= planep[x-1];
218 for (x = 0; x < stride * height; x++)
219 planep[x] = !planep[x]; //FIXME stride
221 return (imode << 1) + invert;
224 /** @} */ //Bitplane group
226 /***********************************************************************/
227 /** VOP Dquant decoding
228 * @param v VC-1 Context
230 static int vop_dquant_decoding(VC1Context *v)
232 GetBitContext *gb = &v->s.gb;
236 if (v->dquant != 2) {
237 v->dquantfrm = get_bits1(gb);
241 v->dqprofile = get_bits(gb, 2);
242 switch (v->dqprofile) {
243 case DQPROFILE_SINGLE_EDGE:
244 case DQPROFILE_DOUBLE_EDGES:
245 v->dqsbedge = get_bits(gb, 2);
247 case DQPROFILE_ALL_MBS:
248 v->dqbilevel = get_bits1(gb);
258 pqdiff = get_bits(gb, 3);
260 v->altpq = get_bits(gb, 5);
262 v->altpq = v->pq + pqdiff + 1;
267 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
270 * Decode Simple/Main Profiles sequence header
271 * @see Figure 7-8, p16-17
272 * @param avctx Codec context
273 * @param gb GetBit context initialized from Codec context extra_data
276 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
278 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
279 v->profile = get_bits(gb, 2);
280 if (v->profile == PROFILE_COMPLEX) {
281 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
284 if (v->profile == PROFILE_ADVANCED) {
285 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
286 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
287 return decode_sequence_header_adv(v, gb);
290 v->zz_8x4 = ff_wmv2_scantableA;
291 v->zz_4x8 = ff_wmv2_scantableB;
292 v->res_y411 = get_bits1(gb);
293 v->res_sprite = get_bits1(gb);
295 av_log(avctx, AV_LOG_ERROR,
296 "Old interlaced mode is not supported\n");
302 v->frmrtq_postproc = get_bits(gb, 3); //common
303 // (bitrate-32kbps)/64kbps
304 v->bitrtq_postproc = get_bits(gb, 5); //common
305 v->s.loop_filter = get_bits1(gb); //common
306 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
307 av_log(avctx, AV_LOG_ERROR,
308 "LOOPFILTER shall not be enabled in Simple Profile\n");
310 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
311 v->s.loop_filter = 0;
313 v->res_x8 = get_bits1(gb); //reserved
314 v->multires = get_bits1(gb);
315 v->res_fasttx = get_bits1(gb);
316 if (!v->res_fasttx) {
317 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_int16_8bit;
318 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
319 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
320 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
321 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_int16_8bit;
322 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
323 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
324 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
327 v->fastuvmc = get_bits1(gb); //common
328 if (!v->profile && !v->fastuvmc) {
329 av_log(avctx, AV_LOG_ERROR,
330 "FASTUVMC unavailable in Simple Profile\n");
333 v->extended_mv = get_bits1(gb); //common
334 if (!v->profile && v->extended_mv) {
335 av_log(avctx, AV_LOG_ERROR,
336 "Extended MVs unavailable in Simple Profile\n");
339 v->dquant = get_bits(gb, 2); //common
340 v->vstransform = get_bits1(gb); //common
342 v->res_transtab = get_bits1(gb);
343 if (v->res_transtab) {
344 av_log(avctx, AV_LOG_ERROR,
345 "1 for reserved RES_TRANSTAB is forbidden\n");
349 v->overlap = get_bits1(gb); //common
351 v->resync_marker = get_bits1(gb);
352 v->rangered = get_bits1(gb);
353 if (v->rangered && v->profile == PROFILE_SIMPLE) {
354 av_log(avctx, AV_LOG_INFO,
355 "RANGERED should be set to 0 in Simple Profile\n");
358 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
359 v->quantizer_mode = get_bits(gb, 2); //common
361 v->finterpflag = get_bits1(gb); //common
364 int w = get_bits(gb, 11);
365 int h = get_bits(gb, 11);
366 int ret = ff_set_dimensions(v->s.avctx, w, h);
368 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
371 skip_bits(gb, 5); //frame rate
372 v->res_x8 = get_bits1(gb);
373 if (get_bits1(gb)) { // something to do with DC VLC selection
374 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
377 skip_bits(gb, 3); //slice code
380 v->res_rtm_flag = get_bits1(gb); //reserved
382 //TODO: figure out what they mean (always 0x402F)
385 av_log(avctx, AV_LOG_DEBUG,
386 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
387 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
388 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
389 "DQuant=%i, Quantizer mode=%i, Max B-frames=%i\n",
390 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
391 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
392 v->rangered, v->vstransform, v->overlap, v->resync_marker,
393 v->dquant, v->quantizer_mode, avctx->max_b_frames);
397 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
400 v->level = get_bits(gb, 3);
402 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
404 v->chromaformat = get_bits(gb, 2);
405 if (v->chromaformat != 1) {
406 av_log(v->s.avctx, AV_LOG_ERROR,
407 "Only 4:2:0 chroma format supported\n");
412 v->frmrtq_postproc = get_bits(gb, 3); //common
413 // (bitrate-32kbps)/64kbps
414 v->bitrtq_postproc = get_bits(gb, 5); //common
415 v->postprocflag = get_bits1(gb); //common
417 v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
418 v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
419 v->broadcast = get_bits1(gb);
420 v->interlace = get_bits1(gb);
421 v->tfcntrflag = get_bits1(gb);
422 v->finterpflag = get_bits1(gb);
423 skip_bits1(gb); // reserved
425 av_log(v->s.avctx, AV_LOG_DEBUG,
426 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
427 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
428 "TFCTRflag=%i, FINTERPflag=%i\n",
429 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
430 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
431 v->tfcntrflag, v->finterpflag);
433 v->psf = get_bits1(gb);
434 if (v->psf) { //PsF, 6.1.13
435 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
438 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
439 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
441 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
442 w = get_bits(gb, 14) + 1;
443 h = get_bits(gb, 14) + 1;
444 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
446 ar = get_bits(gb, 4);
448 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
449 } else if (ar == 15) {
450 w = get_bits(gb, 8) + 1;
451 h = get_bits(gb, 8) + 1;
452 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
454 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
455 &v->s.avctx->sample_aspect_ratio.den,
456 v->s.avctx->height * w,
457 v->s.avctx->width * h,
460 ff_set_sar(v->s.avctx, v->s.avctx->sample_aspect_ratio);
461 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
462 v->s.avctx->sample_aspect_ratio.num,
463 v->s.avctx->sample_aspect_ratio.den);
465 if (get_bits1(gb)) { //framerate stuff
467 v->s.avctx->framerate.den = 32;
468 v->s.avctx->framerate.num = get_bits(gb, 16) + 1;
471 nr = get_bits(gb, 8);
472 dr = get_bits(gb, 4);
473 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
474 v->s.avctx->framerate.den = ff_vc1_fps_dr[dr - 1];
475 v->s.avctx->framerate.num = ff_vc1_fps_nr[nr - 1] * 1000;
478 if (v->broadcast) { // Pulldown may be present
479 v->s.avctx->ticks_per_frame = 2;
484 v->color_prim = get_bits(gb, 8);
485 v->transfer_char = get_bits(gb, 8);
486 v->matrix_coef = get_bits(gb, 8);
490 v->hrd_param_flag = get_bits1(gb);
491 if (v->hrd_param_flag) {
493 v->hrd_num_leaky_buckets = get_bits(gb, 5);
494 skip_bits(gb, 4); //bitrate exponent
495 skip_bits(gb, 4); //buffer size exponent
496 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
497 skip_bits(gb, 16); //hrd_rate[n]
498 skip_bits(gb, 16); //hrd_buffer[n]
504 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
510 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
511 v->broken_link = get_bits1(gb);
512 v->closed_entry = get_bits1(gb);
513 v->panscanflag = get_bits1(gb);
514 v->refdist_flag = get_bits1(gb);
515 v->s.loop_filter = get_bits1(gb);
516 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
517 v->s.loop_filter = 0;
518 v->fastuvmc = get_bits1(gb);
519 v->extended_mv = get_bits1(gb);
520 v->dquant = get_bits(gb, 2);
521 v->vstransform = get_bits1(gb);
522 v->overlap = get_bits1(gb);
523 v->quantizer_mode = get_bits(gb, 2);
525 if (v->hrd_param_flag) {
526 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
527 skip_bits(gb, 8); //hrd_full[n]
532 w = (get_bits(gb, 12)+1)<<1;
533 h = (get_bits(gb, 12)+1)<<1;
535 w = v->max_coded_width;
536 h = v->max_coded_height;
538 if ((ret = ff_set_dimensions(avctx, w, h)) < 0) {
539 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
544 v->extended_dmv = get_bits1(gb);
545 if ((v->range_mapy_flag = get_bits1(gb))) {
546 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
547 v->range_mapy = get_bits(gb, 3);
549 if ((v->range_mapuv_flag = get_bits1(gb))) {
550 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
551 v->range_mapuv = get_bits(gb, 3);
554 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
555 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
556 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
557 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
558 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
559 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
564 /* fill lookup tables for intensity compensation */
565 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \
566 int scale, shift, i; \
569 shift = (255 - lumshift * 2) * 64; \
573 scale = lumscale + 32; \
575 shift = (lumshift - 64) * 64; \
577 shift = lumshift << 6; \
579 for (i = 0; i < 256; i++) { \
580 int iy = chain ? luty[i] : i; \
581 int iu = chain ? lutuv[i] : i; \
582 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
583 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
587 static void rotate_luts(VC1Context *v)
589 #define ROTATE(DEF, L, N, C, A) do { \
590 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
594 memcpy(&tmp, L , sizeof(tmp)); \
595 memcpy(L , N , sizeof(tmp)); \
596 memcpy(N , &tmp, sizeof(tmp)); \
601 ROTATE(int tmp, &v->last_use_ic, &v->next_use_ic, v->curr_use_ic, &v->aux_use_ic);
602 ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
603 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
605 INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
606 INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
610 static int read_bfraction(VC1Context *v, GetBitContext* gb) {
611 int bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
613 if (bfraction_lut_index == 21 || bfraction_lut_index < 0) {
614 av_log(v->s.avctx, AV_LOG_ERROR, "bfraction invalid\n");
615 return AVERROR_INVALIDDATA;
617 v->bfraction_lut_index = bfraction_lut_index;
618 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
622 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
624 int pqindex, lowquant, status;
627 v->fcm = PROGRESSIVE;
629 v->interpfrm = get_bits1(gb);
630 if (!v->s.avctx->codec)
632 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
635 v->multires = get_bits(gb, 2) == 1;
637 skip_bits(gb, 2); //framecnt unused
640 v->rangeredfrm = get_bits1(gb);
642 v->s.pict_type = AV_PICTURE_TYPE_P;
644 if (v->s.avctx->max_b_frames && !get_bits1(gb)) {
645 v->s.pict_type = AV_PICTURE_TYPE_B;
647 v->s.pict_type = AV_PICTURE_TYPE_I;
651 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
652 if (read_bfraction(v, gb) < 0)
653 return AVERROR_INVALIDDATA;
654 if (v->bfraction == 0) {
655 v->s.pict_type = AV_PICTURE_TYPE_BI;
658 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
659 skip_bits(gb, 7); // skip buffer fullness
665 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
667 if (v->s.pict_type == AV_PICTURE_TYPE_P)
670 /* Quantizer stuff */
671 pqindex = get_bits(gb, 5);
674 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
675 v->pq = ff_vc1_pquant_table[0][pqindex];
677 v->pq = ff_vc1_pquant_table[1][pqindex];
678 v->pqindex = pqindex;
680 v->halfpq = get_bits1(gb);
683 switch (v->quantizer_mode) {
684 case QUANT_FRAME_IMPLICIT:
685 v->pquantizer = pqindex < 9;
687 case QUANT_NON_UNIFORM:
690 case QUANT_FRAME_EXPLICIT:
691 v->pquantizer = get_bits1(gb);
698 if (v->extended_mv == 1)
699 v->mvrange = get_unary(gb, 0, 3);
700 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
701 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
702 v->range_x = 1 << (v->k_x - 1);
703 v->range_y = 1 << (v->k_y - 1);
704 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
705 v->respic = get_bits(gb, 2);
707 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
708 v->x8_type = get_bits1(gb);
711 ff_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
712 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
713 pqindex, v->pq, v->halfpq, v->rangeredfrm);
715 if (v->first_pic_header_flag)
718 switch (v->s.pict_type) {
719 case AV_PICTURE_TYPE_P:
720 v->tt_index = (v->pq > 4) + (v->pq > 12);
722 lowquant = (v->pq > 12) ? 0 : 1;
723 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
724 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
725 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
726 v->lumscale = get_bits(gb, 6);
727 v->lumshift = get_bits(gb, 6);
729 /* fill lookup tables for intensity compensation */
730 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
731 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
733 v->qs_last = v->s.quarter_sample;
734 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
735 v->s.quarter_sample = (v->mv_mode2 != MV_PMODE_1MV_HPEL &&
736 v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
737 v->s.mspel = (v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
739 v->s.quarter_sample = (v->mv_mode != MV_PMODE_1MV_HPEL &&
740 v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
741 v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
744 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
745 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
746 v->mv_mode == MV_PMODE_MIXED_MV) {
747 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
750 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
751 "Imode: %i, Invert: %i\n", status>>1, status&1);
753 v->mv_type_is_raw = 0;
754 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
756 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
759 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
760 "Imode: %i, Invert: %i\n", status>>1, status&1);
762 /* Hopefully this is correct for P-frames */
763 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
764 v->cbptab = get_bits(gb, 2);
765 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
768 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
769 vop_dquant_decoding(v);
772 if (v->vstransform) {
773 v->ttmbf = get_bits1(gb);
775 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
777 v->ttfrm = 0; //FIXME Is that so ?
783 case AV_PICTURE_TYPE_B:
784 v->tt_index = (v->pq > 4) + (v->pq > 12);
786 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
787 v->qs_last = v->s.quarter_sample;
788 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
789 v->s.mspel = v->s.quarter_sample;
791 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
794 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
795 "Imode: %i, Invert: %i\n", status>>1, status&1);
796 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
799 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
800 "Imode: %i, Invert: %i\n", status>>1, status&1);
802 v->s.mv_table_index = get_bits(gb, 2);
803 v->cbptab = get_bits(gb, 2);
804 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
807 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
808 vop_dquant_decoding(v);
811 if (v->vstransform) {
812 v->ttmbf = get_bits1(gb);
814 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
826 v->c_ac_table_index = decode012(gb);
827 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
828 v->y_ac_table_index = decode012(gb);
831 v->s.dc_table_index = get_bits1(gb);
834 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
835 v->s.pict_type = AV_PICTURE_TYPE_B;
841 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
843 int pqindex, lowquant;
848 v->p_frame_skipped = 0;
849 if (v->second_field) {
850 if (v->fcm != ILACE_FIELD || v->field_mode!=1)
853 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
855 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
856 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
857 if (!v->pic_header_flag)
858 goto parse_common_info;
865 if (fcm == ILACE_FIELD)
871 if (!v->first_pic_header_flag && v->field_mode != field_mode)
872 return AVERROR_INVALIDDATA;
873 v->field_mode = field_mode;
876 av_assert0( v->s.mb_height == v->s.height + 15 >> 4
877 || v->s.mb_height == FFALIGN(v->s.height + 15 >> 4, 2));
879 v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
880 v->fptype = get_bits(gb, 3);
881 if (v->fptype & 4) // B-picture
882 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
884 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
886 v->s.mb_height = v->s.height + 15 >> 4;
887 switch (get_unary(gb, 0, 4)) {
889 v->s.pict_type = AV_PICTURE_TYPE_P;
892 v->s.pict_type = AV_PICTURE_TYPE_B;
895 v->s.pict_type = AV_PICTURE_TYPE_I;
898 v->s.pict_type = AV_PICTURE_TYPE_BI;
901 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
902 v->p_frame_skipped = 1;
909 if (!v->interlace || v->psf) {
910 v->rptfrm = get_bits(gb, 2);
912 v->tff = get_bits1(gb);
913 v->rff = get_bits1(gb);
918 if (v->panscanflag) {
919 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
922 if (v->p_frame_skipped) {
925 v->rnd = get_bits1(gb);
927 v->uvsamp = get_bits1(gb);
928 if(!ff_vc1_bfraction_vlc.table)
929 return 0; //parsing only, vlc tables havnt been allocated
931 if (!v->refdist_flag)
933 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
934 v->refdist = get_bits(gb, 2);
936 v->refdist += get_unary(gb, 0, 16);
938 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
939 if (read_bfraction(v, gb) < 0)
940 return AVERROR_INVALIDDATA;
941 v->frfd = (v->bfraction * v->refdist) >> 8;
942 v->brfd = v->refdist - v->frfd - 1;
946 goto parse_common_info;
948 if (v->fcm == PROGRESSIVE) {
950 v->interpfrm = get_bits1(gb);
951 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
952 if (read_bfraction(v, gb) < 0)
953 return AVERROR_INVALIDDATA;
954 if (v->bfraction == 0) {
955 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
962 v->cur_field_type = !(v->tff ^ v->second_field);
963 pqindex = get_bits(gb, 5);
966 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
967 v->pq = ff_vc1_pquant_table[0][pqindex];
969 v->pq = ff_vc1_pquant_table[1][pqindex];
970 v->pqindex = pqindex;
972 v->halfpq = get_bits1(gb);
975 switch (v->quantizer_mode) {
976 case QUANT_FRAME_IMPLICIT:
977 v->pquantizer = pqindex < 9;
979 case QUANT_NON_UNIFORM:
982 case QUANT_FRAME_EXPLICIT:
983 v->pquantizer = get_bits1(gb);
991 v->postproc = get_bits(gb, 2);
996 if (v->first_pic_header_flag)
999 switch (v->s.pict_type) {
1000 case AV_PICTURE_TYPE_I:
1001 case AV_PICTURE_TYPE_BI:
1002 if (v->fcm == ILACE_FRAME) { //interlace frame picture
1003 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
1006 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1007 "Imode: %i, Invert: %i\n", status>>1, status&1);
1009 v->fieldtx_is_raw = 0;
1010 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1013 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1014 "Imode: %i, Invert: %i\n", status>>1, status&1);
1015 v->condover = CONDOVER_NONE;
1016 if (v->overlap && v->pq <= 8) {
1017 v->condover = decode012(gb);
1018 if (v->condover == CONDOVER_SELECT) {
1019 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1022 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1023 "Imode: %i, Invert: %i\n", status>>1, status&1);
1027 case AV_PICTURE_TYPE_P:
1028 if (v->field_mode) {
1029 v->numref = get_bits1(gb);
1031 v->reffield = get_bits1(gb);
1032 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1036 v->mvrange = get_unary(gb, 0, 3);
1040 if (v->extended_dmv)
1041 v->dmvrange = get_unary(gb, 0, 3);
1044 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1045 v->fourmvswitch = get_bits1(gb);
1046 v->intcomp = get_bits1(gb);
1048 v->lumscale = get_bits(gb, 6);
1049 v->lumshift = get_bits(gb, 6);
1050 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1051 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1054 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1057 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1058 "Imode: %i, Invert: %i\n", status>>1, status&1);
1059 v->mbmodetab = get_bits(gb, 2);
1060 if (v->fourmvswitch)
1061 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[v->mbmodetab];
1063 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[v->mbmodetab];
1064 v->imvtab = get_bits(gb, 2);
1065 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1066 // interlaced p-picture cbpcy range is [1, 63]
1067 v->icbptab = get_bits(gb, 3);
1068 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1069 v->twomvbptab = get_bits(gb, 2);
1070 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[v->twomvbptab];
1071 if (v->fourmvswitch) {
1072 v->fourmvbptab = get_bits(gb, 2);
1073 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1077 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1078 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1079 v->range_x = 1 << (v->k_x - 1);
1080 v->range_y = 1 << (v->k_y - 1);
1082 v->tt_index = (v->pq > 4) + (v->pq > 12);
1083 if (v->fcm != ILACE_FRAME) {
1085 mvmode = get_unary(gb, 1, 4);
1086 lowquant = (v->pq > 12) ? 0 : 1;
1087 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1088 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1090 mvmode2 = get_unary(gb, 1, 3);
1091 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1092 if (v->field_mode) {
1093 v->intcompfield = decode210(gb) ^ 3;
1095 v->intcompfield = 3;
1097 v->lumscale2 = v->lumscale = 32;
1098 v->lumshift2 = v->lumshift = 0;
1099 if (v->intcompfield & 1) {
1100 v->lumscale = get_bits(gb, 6);
1101 v->lumshift = get_bits(gb, 6);
1103 if ((v->intcompfield & 2) && v->field_mode) {
1104 v->lumscale2 = get_bits(gb, 6);
1105 v->lumshift2 = get_bits(gb, 6);
1106 } else if(!v->field_mode) {
1107 v->lumscale2 = v->lumscale;
1108 v->lumshift2 = v->lumshift;
1110 if (v->field_mode && v->second_field) {
1111 if (v->cur_field_type) {
1112 INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1113 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1115 INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1116 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1118 v->next_use_ic = *v->curr_use_ic = 1;
1120 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1121 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1125 v->qs_last = v->s.quarter_sample;
1126 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1127 v->s.quarter_sample = (v->mv_mode2 != MV_PMODE_1MV_HPEL &&
1128 v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
1129 v->s.mspel = (v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
1131 v->s.quarter_sample = (v->mv_mode != MV_PMODE_1MV_HPEL &&
1132 v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1133 v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1136 if (v->fcm == PROGRESSIVE) { // progressive
1137 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1138 v->mv_mode2 == MV_PMODE_MIXED_MV)
1139 || v->mv_mode == MV_PMODE_MIXED_MV) {
1140 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1143 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1144 "Imode: %i, Invert: %i\n", status>>1, status&1);
1146 v->mv_type_is_raw = 0;
1147 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1149 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1152 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1153 "Imode: %i, Invert: %i\n", status>>1, status&1);
1155 /* Hopefully this is correct for P-frames */
1156 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1157 v->cbptab = get_bits(gb, 2);
1158 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
1159 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1160 v->qs_last = v->s.quarter_sample;
1161 v->s.quarter_sample = 1;
1163 } else { // field interlaced
1164 v->mbmodetab = get_bits(gb, 3);
1165 v->imvtab = get_bits(gb, 2 + v->numref);
1167 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1169 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[v->imvtab];
1170 v->icbptab = get_bits(gb, 3);
1171 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1172 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1173 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1174 v->fourmvbptab = get_bits(gb, 2);
1175 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1176 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[v->mbmodetab];
1178 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[v->mbmodetab];
1182 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1183 vop_dquant_decoding(v);
1186 if (v->vstransform) {
1187 v->ttmbf = get_bits1(gb);
1189 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1191 v->ttfrm = 0; //FIXME Is that so ?
1197 case AV_PICTURE_TYPE_B:
1198 if (v->fcm == ILACE_FRAME) {
1199 if (read_bfraction(v, gb) < 0)
1200 return AVERROR_INVALIDDATA;
1201 if (v->bfraction == 0) {
1206 v->mvrange = get_unary(gb, 0, 3);
1209 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1210 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1211 v->range_x = 1 << (v->k_x - 1);
1212 v->range_y = 1 << (v->k_y - 1);
1214 v->tt_index = (v->pq > 4) + (v->pq > 12);
1216 if (v->field_mode) {
1218 av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1219 if (v->extended_dmv)
1220 v->dmvrange = get_unary(gb, 0, 3);
1221 mvmode = get_unary(gb, 1, 3);
1222 lowquant = (v->pq > 12) ? 0 : 1;
1223 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1224 v->qs_last = v->s.quarter_sample;
1225 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1226 v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1227 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1230 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1231 "Imode: %i, Invert: %i\n", status>>1, status&1);
1232 v->mbmodetab = get_bits(gb, 3);
1233 if (v->mv_mode == MV_PMODE_MIXED_MV)
1234 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[v->mbmodetab];
1236 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[v->mbmodetab];
1237 v->imvtab = get_bits(gb, 3);
1238 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[v->imvtab];
1239 v->icbptab = get_bits(gb, 3);
1240 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1241 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1242 v->fourmvbptab = get_bits(gb, 2);
1243 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1245 v->numref = 1; // interlaced field B pictures are always 2-ref
1246 } else if (v->fcm == ILACE_FRAME) {
1247 if (v->extended_dmv)
1248 v->dmvrange = get_unary(gb, 0, 3);
1249 if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1250 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1252 v->mv_mode = MV_PMODE_1MV;
1253 v->fourmvswitch = 0;
1254 v->qs_last = v->s.quarter_sample;
1255 v->s.quarter_sample = 1;
1257 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1260 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1261 "Imode: %i, Invert: %i\n", status>>1, status&1);
1262 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1265 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1266 "Imode: %i, Invert: %i\n", status>>1, status&1);
1267 v->mbmodetab = get_bits(gb, 2);
1268 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[v->mbmodetab];
1269 v->imvtab = get_bits(gb, 2);
1270 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1271 // interlaced p/b-picture cbpcy range is [1, 63]
1272 v->icbptab = get_bits(gb, 3);
1273 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1274 v->twomvbptab = get_bits(gb, 2);
1275 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[v->twomvbptab];
1276 v->fourmvbptab = get_bits(gb, 2);
1277 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1279 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1280 v->qs_last = v->s.quarter_sample;
1281 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1282 v->s.mspel = v->s.quarter_sample;
1283 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1286 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1287 "Imode: %i, Invert: %i\n", status>>1, status&1);
1288 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1291 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1292 "Imode: %i, Invert: %i\n", status>>1, status&1);
1293 v->s.mv_table_index = get_bits(gb, 2);
1294 v->cbptab = get_bits(gb, 2);
1295 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
1299 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1300 vop_dquant_decoding(v);
1303 if (v->vstransform) {
1304 v->ttmbf = get_bits1(gb);
1306 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1316 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1322 v->c_ac_table_index = decode012(gb);
1323 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1324 v->y_ac_table_index = decode012(gb);
1327 v->s.dc_table_index = get_bits1(gb);
1328 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1330 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1331 vop_dquant_decoding(v);
1334 v->bi_type = (v->s.pict_type == AV_PICTURE_TYPE_BI);
1336 v->s.pict_type = AV_PICTURE_TYPE_B;
1341 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1343 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1344 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1345 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1346 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1347 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1348 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1349 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1350 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1351 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1352 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1353 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1354 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1355 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1356 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1357 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1358 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1359 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1360 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1361 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1362 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1363 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1364 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1365 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1366 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1367 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1368 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1369 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1370 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1371 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1372 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1373 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1376 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1377 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1378 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1379 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1380 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1381 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1382 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1383 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1384 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1385 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1386 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1387 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1388 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1389 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1390 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1391 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1392 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1393 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1394 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1395 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1396 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1397 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1398 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1399 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1400 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1401 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1402 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1403 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1407 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1408 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1409 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1410 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1411 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1412 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1413 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1414 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1415 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1416 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1417 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1418 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1419 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1420 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1421 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1422 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1423 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1424 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1425 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1426 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1427 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1428 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1432 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1433 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1434 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1435 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1436 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1437 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1438 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1439 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1440 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1441 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1442 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1443 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1444 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1445 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1446 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1447 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1448 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1449 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1450 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1451 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1452 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1453 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1454 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1455 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1456 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1459 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1460 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1461 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1462 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1463 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1464 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1465 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1466 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1467 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1468 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1469 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1470 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1471 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1472 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1473 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1474 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1475 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1479 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1480 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1481 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1482 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1483 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1484 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1485 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1486 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1487 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1488 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1489 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1490 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1491 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1492 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1493 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1494 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1495 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1499 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1500 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1501 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1502 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1503 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1504 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1505 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1506 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1507 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1508 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1509 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1510 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1511 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1512 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1513 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1514 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1515 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1516 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1517 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1518 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1519 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1520 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1521 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1522 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1523 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1524 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1525 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1529 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1530 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1531 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1532 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1533 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1534 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1535 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1536 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1537 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1538 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1539 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1540 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1541 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1542 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1543 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1544 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1545 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1546 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1547 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1548 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1549 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1550 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1551 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1552 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1553 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1554 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1555 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1556 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1557 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1562 static const uint16_t vlc_offs[] = {
1563 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1564 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1565 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1566 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1567 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1568 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1569 31714, 31746, 31778, 32306, 32340, 32372
1573 * Init VC-1 specific tables and VC1Context members
1574 * @param v The VC1Context to initialize
1577 av_cold int ff_vc1_init_common(VC1Context *v)
1579 static int done = 0;
1581 static VLC_TYPE vlc_table[32372][2];
1583 v->hrd_rate = v->hrd_buffer = NULL;
1587 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1588 ff_vc1_bfraction_bits, 1, 1,
1589 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1590 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1591 ff_vc1_norm2_bits, 1, 1,
1592 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1593 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1594 ff_vc1_norm6_bits, 1, 1,
1595 ff_vc1_norm6_codes, 2, 2, 556);
1596 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1597 ff_vc1_imode_bits, 1, 1,
1598 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1599 for (i = 0; i < 3; i++) {
1600 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1601 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1602 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1603 ff_vc1_ttmb_bits[i], 1, 1,
1604 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1605 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1606 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1607 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1608 ff_vc1_ttblk_bits[i], 1, 1,
1609 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1610 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1611 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1612 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1613 ff_vc1_subblkpat_bits[i], 1, 1,
1614 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1616 for (i = 0; i < 4; i++) {
1617 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1618 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1619 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1620 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1621 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1622 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1623 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1624 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1625 ff_vc1_cbpcy_p_bits[i], 1, 1,
1626 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1627 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1628 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1629 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1630 ff_vc1_mv_diff_bits[i], 1, 1,
1631 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1633 for (i = 0; i < 8; i++) {
1634 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1635 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1636 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1637 &vc1_ac_tables[i][0][1], 8, 4,
1638 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1639 /* initialize interlaced MVDATA tables (2-Ref) */
1640 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1641 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1642 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1643 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1644 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1646 for (i = 0; i < 4; i++) {
1647 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1648 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1649 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1650 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1651 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1652 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1653 /* initialize NON-4MV MBMODE VLC tables for the same */
1654 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1655 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1656 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1657 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1658 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1659 /* initialize interlaced MVDATA tables (1-Ref) */
1660 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1661 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1662 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1663 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1664 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1666 for (i = 0; i < 4; i++) {
1667 /* Initialize 2MV Block pattern VLC tables */
1668 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1669 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1670 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1671 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1672 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1674 for (i = 0; i < 8; i++) {
1675 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1676 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1677 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1678 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1679 ff_vc1_icbpcy_p_bits[i], 1, 1,
1680 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1681 /* Initialize interlaced field picture MBMODE VLC tables */
1682 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1683 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1684 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1685 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1686 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1687 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1688 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1689 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1690 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1691 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1696 /* Other defaults */
1698 v->mvrange = 0; /* 7.1.1.18, p80 */
1700 ff_vc1dsp_init(&v->vc1dsp);