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
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
50 /** Decode rows by checking if they are skipped
51 * @param plane Buffer to store decoded bits
52 * @param[in] width Width of this buffer
53 * @param[in] height Height of this buffer
54 * @param[in] stride of this buffer
56 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
61 for (y = 0; y < height; y++) {
62 if (!get_bits1(gb)) //rowskip
63 memset(plane, 0, width);
65 for (x = 0; x < width; x++)
66 plane[x] = get_bits1(gb);
71 /** Decode columns by checking if they are skipped
72 * @param plane Buffer to store decoded bits
73 * @param[in] width Width of this buffer
74 * @param[in] height Height of this buffer
75 * @param[in] stride of this buffer
76 * @todo FIXME: Optimize
78 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
83 for (x = 0; x < width; x++) {
84 if (!get_bits1(gb)) //colskip
85 for (y = 0; y < height; y++)
88 for (y = 0; y < height; y++)
89 plane[y*stride] = get_bits1(gb);
94 /** Decode a bitplane's bits
95 * @param data bitplane where to store the decode bits
96 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
97 * @param v VC-1 context for bit reading and logging
99 * @todo FIXME: Optimize
101 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
103 GetBitContext *gb = &v->s.gb;
105 int imode, x, y, code, offset;
106 uint8_t invert, *planep = data;
107 int width, height, stride;
109 width = v->s.mb_width;
110 height = v->s.mb_height >> v->field_mode;
111 stride = v->s.mb_stride;
112 invert = get_bits1(gb);
113 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
118 //Data is actually read in the MB layer (same for all tests == "raw")
119 *raw_flag = 1; //invert ignored
123 if ((height * width) & 1) {
124 *planep++ = get_bits1(gb);
126 if (offset == width) {
128 planep += stride - width;
133 // decode bitplane as one long line
134 for (; y < height * width; y += 2) {
135 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
136 *planep++ = code & 1;
138 if (offset == width) {
140 planep += stride - width;
142 *planep++ = code >> 1;
144 if (offset == width) {
146 planep += stride - width;
152 if (!(height % 3) && (width % 3)) { // use 2x3 decoding
153 for (y = 0; y < height; y += 3) {
154 for (x = width & 1; x < width; x += 2) {
155 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
157 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
160 planep[x + 0] = (code >> 0) & 1;
161 planep[x + 1] = (code >> 1) & 1;
162 planep[x + 0 + stride] = (code >> 2) & 1;
163 planep[x + 1 + stride] = (code >> 3) & 1;
164 planep[x + 0 + stride * 2] = (code >> 4) & 1;
165 planep[x + 1 + stride * 2] = (code >> 5) & 1;
167 planep += stride * 3;
170 decode_colskip(data, 1, height, stride, &v->s.gb);
172 planep += (height & 1) * stride;
173 for (y = height & 1; y < height; y += 2) {
174 for (x = width % 3; x < width; x += 3) {
175 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
177 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
180 planep[x + 0] = (code >> 0) & 1;
181 planep[x + 1] = (code >> 1) & 1;
182 planep[x + 2] = (code >> 2) & 1;
183 planep[x + 0 + stride] = (code >> 3) & 1;
184 planep[x + 1 + stride] = (code >> 4) & 1;
185 planep[x + 2 + stride] = (code >> 5) & 1;
187 planep += stride * 2;
191 decode_colskip(data, x, height, stride, &v->s.gb);
193 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
197 decode_rowskip(data, width, height, stride, &v->s.gb);
200 decode_colskip(data, width, height, stride, &v->s.gb);
206 /* Applying diff operator */
207 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
210 for (x = 1; x < width; x++)
211 planep[x] ^= planep[x-1];
212 for (y = 1; y < height; y++) {
214 planep[0] ^= planep[-stride];
215 for (x = 1; x < width; x++) {
216 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
217 else planep[x] ^= planep[x-1];
222 for (x = 0; x < stride * height; x++)
223 planep[x] = !planep[x]; //FIXME stride
225 return (imode << 1) + invert;
228 /** @} */ //Bitplane group
230 /***********************************************************************/
231 /** VOP Dquant decoding
232 * @param v VC-1 Context
234 static int vop_dquant_decoding(VC1Context *v)
236 GetBitContext *gb = &v->s.gb;
240 if (v->dquant == 2) {
241 pqdiff = get_bits(gb, 3);
243 v->altpq = get_bits(gb, 5);
245 v->altpq = v->pq + pqdiff + 1;
247 v->dquantfrm = get_bits1(gb);
249 v->dqprofile = get_bits(gb, 2);
250 switch (v->dqprofile) {
251 case DQPROFILE_SINGLE_EDGE:
252 case DQPROFILE_DOUBLE_EDGES:
253 v->dqsbedge = get_bits(gb, 2);
255 case DQPROFILE_ALL_MBS:
256 v->dqbilevel = get_bits1(gb);
262 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
263 pqdiff = get_bits(gb, 3);
265 v->altpq = get_bits(gb, 5);
267 v->altpq = v->pq + pqdiff + 1;
274 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
277 * Decode Simple/Main Profiles sequence header
278 * @see Figure 7-8, p16-17
279 * @param avctx Codec context
280 * @param gb GetBit context initialized from Codec context extra_data
283 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
285 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
286 v->profile = get_bits(gb, 2);
287 if (v->profile == PROFILE_COMPLEX) {
288 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
291 if (v->profile == PROFILE_ADVANCED) {
292 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
293 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
294 return decode_sequence_header_adv(v, gb);
297 v->zz_8x4 = ff_wmv2_scantableA;
298 v->zz_4x8 = ff_wmv2_scantableB;
299 v->res_y411 = get_bits1(gb);
300 v->res_sprite = get_bits1(gb);
302 av_log(avctx, AV_LOG_ERROR,
303 "Old interlaced mode is not supported\n");
309 v->frmrtq_postproc = get_bits(gb, 3); //common
310 // (bitrate-32kbps)/64kbps
311 v->bitrtq_postproc = get_bits(gb, 5); //common
312 v->s.loop_filter = get_bits1(gb); //common
313 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
314 av_log(avctx, AV_LOG_ERROR,
315 "LOOPFILTER shall not be enabled in Simple Profile\n");
317 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
318 v->s.loop_filter = 0;
320 v->res_x8 = get_bits1(gb); //reserved
321 v->multires = get_bits1(gb);
322 v->res_fasttx = get_bits1(gb);
323 if (!v->res_fasttx) {
324 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;
325 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
326 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
327 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
328 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
329 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
330 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
331 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
334 v->fastuvmc = get_bits1(gb); //common
335 if (!v->profile && !v->fastuvmc) {
336 av_log(avctx, AV_LOG_ERROR,
337 "FASTUVMC unavailable in Simple Profile\n");
340 v->extended_mv = get_bits1(gb); //common
341 if (!v->profile && v->extended_mv)
343 av_log(avctx, AV_LOG_ERROR,
344 "Extended MVs unavailable in Simple Profile\n");
347 v->dquant = get_bits(gb, 2); //common
348 v->vstransform = get_bits1(gb); //common
350 v->res_transtab = get_bits1(gb);
353 av_log(avctx, AV_LOG_ERROR,
354 "1 for reserved RES_TRANSTAB is forbidden\n");
358 v->overlap = get_bits1(gb); //common
360 v->resync_marker = get_bits1(gb);
361 v->rangered = get_bits1(gb);
362 if (v->rangered && v->profile == PROFILE_SIMPLE) {
363 av_log(avctx, AV_LOG_INFO,
364 "RANGERED should be set to 0 in Simple Profile\n");
367 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
368 v->quantizer_mode = get_bits(gb, 2); //common
370 v->finterpflag = get_bits1(gb); //common
373 int w = get_bits(gb, 11);
374 int h = get_bits(gb, 11);
375 int ret = ff_set_dimensions(v->s.avctx, w, h);
377 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
380 skip_bits(gb, 5); //frame rate
381 v->res_x8 = get_bits1(gb);
382 if (get_bits1(gb)) { // something to do with DC VLC selection
383 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
386 skip_bits(gb, 3); //slice code
389 v->res_rtm_flag = get_bits1(gb); //reserved
391 if (!v->res_rtm_flag) {
392 av_log(avctx, AV_LOG_ERROR,
393 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
396 //TODO: figure out what they mean (always 0x402F)
399 av_log(avctx, AV_LOG_DEBUG,
400 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
401 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
402 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
403 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
404 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
405 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
406 v->rangered, v->vstransform, v->overlap, v->resync_marker,
407 v->dquant, v->quantizer_mode, avctx->max_b_frames);
411 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
414 v->level = get_bits(gb, 3);
416 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
418 v->chromaformat = get_bits(gb, 2);
419 if (v->chromaformat != 1) {
420 av_log(v->s.avctx, AV_LOG_ERROR,
421 "Only 4:2:0 chroma format supported\n");
426 v->frmrtq_postproc = get_bits(gb, 3); //common
427 // (bitrate-32kbps)/64kbps
428 v->bitrtq_postproc = get_bits(gb, 5); //common
429 v->postprocflag = get_bits1(gb); //common
431 v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
432 v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
433 v->broadcast = get_bits1(gb);
434 v->interlace = get_bits1(gb);
435 v->tfcntrflag = get_bits1(gb);
436 v->finterpflag = get_bits1(gb);
437 skip_bits1(gb); // reserved
439 av_log(v->s.avctx, AV_LOG_DEBUG,
440 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
441 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
442 "TFCTRflag=%i, FINTERPflag=%i\n",
443 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
444 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
445 v->tfcntrflag, v->finterpflag);
447 v->psf = get_bits1(gb);
448 if (v->psf) { //PsF, 6.1.13
449 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
452 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
453 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
455 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
456 w = get_bits(gb, 14) + 1;
457 h = get_bits(gb, 14) + 1;
458 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
460 ar = get_bits(gb, 4);
462 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
463 } else if (ar == 15) {
464 w = get_bits(gb, 8) + 1;
465 h = get_bits(gb, 8) + 1;
466 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
468 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
469 &v->s.avctx->sample_aspect_ratio.den,
470 v->s.avctx->height * w,
471 v->s.avctx->width * h,
474 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
475 v->s.avctx->sample_aspect_ratio.num,
476 v->s.avctx->sample_aspect_ratio.den);
478 if (get_bits1(gb)) { //framerate stuff
480 v->s.avctx->time_base.num = 32;
481 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
484 nr = get_bits(gb, 8);
485 dr = get_bits(gb, 4);
486 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
487 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
488 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
491 if (v->broadcast) { // Pulldown may be present
492 v->s.avctx->time_base.den *= 2;
493 v->s.avctx->ticks_per_frame = 2;
498 v->s.avctx->color_primaries = get_bits(gb, 8);
499 v->s.avctx->color_trc = get_bits(gb, 8);
500 v->s.avctx->colorspace = get_bits(gb, 8);
501 v->s.avctx->color_range = AVCOL_RANGE_MPEG;
505 v->hrd_param_flag = get_bits1(gb);
506 if (v->hrd_param_flag) {
508 v->hrd_num_leaky_buckets = get_bits(gb, 5);
509 skip_bits(gb, 4); //bitrate exponent
510 skip_bits(gb, 4); //buffer size exponent
511 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
512 skip_bits(gb, 16); //hrd_rate[n]
513 skip_bits(gb, 16); //hrd_buffer[n]
519 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
525 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
526 v->broken_link = get_bits1(gb);
527 v->closed_entry = get_bits1(gb);
528 v->panscanflag = get_bits1(gb);
529 v->refdist_flag = get_bits1(gb);
530 v->s.loop_filter = get_bits1(gb);
531 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
532 v->s.loop_filter = 0;
533 v->fastuvmc = get_bits1(gb);
534 v->extended_mv = get_bits1(gb);
535 v->dquant = get_bits(gb, 2);
536 v->vstransform = get_bits1(gb);
537 v->overlap = get_bits1(gb);
538 v->quantizer_mode = get_bits(gb, 2);
540 if (v->hrd_param_flag) {
541 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
542 skip_bits(gb, 8); //hrd_full[n]
547 w = (get_bits(gb, 12)+1)<<1;
548 h = (get_bits(gb, 12)+1)<<1;
550 w = v->max_coded_width;
551 h = v->max_coded_height;
553 if ((ret = ff_set_dimensions(avctx, w, h)) < 0) {
554 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
559 v->extended_dmv = get_bits1(gb);
560 if ((v->range_mapy_flag = get_bits1(gb))) {
561 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
562 v->range_mapy = get_bits(gb, 3);
564 if ((v->range_mapuv_flag = get_bits1(gb))) {
565 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
566 v->range_mapuv = get_bits(gb, 3);
569 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
570 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
571 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
572 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
573 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
574 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
579 /* fill lookup tables for intensity compensation */
580 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \
581 int scale, shift, i; \
584 shift = (255 - lumshift * 2) << 6; \
588 scale = lumscale + 32; \
590 shift = (lumshift - 64) << 6; \
592 shift = lumshift << 6; \
594 for (i = 0; i < 256; i++) { \
595 int iy = chain ? luty[i] : i; \
596 int iu = chain ? lutuv[i] : i; \
597 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
598 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
602 static void rotate_luts(VC1Context *v)
604 #define ROTATE(DEF, L, N, C, A) do { \
605 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
609 memcpy(&tmp, L , sizeof(tmp)); \
610 memcpy(L , N , sizeof(tmp)); \
611 memcpy(N , &tmp, sizeof(tmp)); \
616 ROTATE(int tmp, &v->last_use_ic, &v->next_use_ic, v->curr_use_ic, &v->aux_use_ic);
617 ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
618 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
620 INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
621 INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
625 static int read_bfraction(VC1Context *v, GetBitContext* gb) {
626 int bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
628 if (bfraction_lut_index == 21 || bfraction_lut_index < 0) {
629 av_log(v->s.avctx, AV_LOG_ERROR, "bfraction invalid\n");
630 return AVERROR_INVALIDDATA;
632 v->bfraction_lut_index = bfraction_lut_index;
633 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
637 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
639 int pqindex, lowquant, status;
644 v->interpfrm = get_bits1(gb);
645 if (!v->s.avctx->codec)
647 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
650 v->multires = get_bits(gb, 2) == 1;
652 skip_bits(gb, 2); //framecnt unused
655 v->rangeredfrm = get_bits1(gb);
656 v->s.pict_type = get_bits1(gb);
657 if (v->s.avctx->max_b_frames) {
658 if (!v->s.pict_type) {
660 v->s.pict_type = AV_PICTURE_TYPE_I;
662 v->s.pict_type = AV_PICTURE_TYPE_B;
664 v->s.pict_type = AV_PICTURE_TYPE_P;
666 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
669 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
670 if (read_bfraction(v, gb) < 0)
671 return AVERROR_INVALIDDATA;
672 if (v->bfraction == 0) {
673 v->s.pict_type = AV_PICTURE_TYPE_BI;
676 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
677 skip_bits(gb, 7); // skip buffer fullness
683 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
685 if (v->s.pict_type == AV_PICTURE_TYPE_P)
688 /* Quantizer stuff */
689 pqindex = get_bits(gb, 5);
692 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
693 v->pq = ff_vc1_pquant_table[0][pqindex];
695 v->pq = ff_vc1_pquant_table[1][pqindex];
698 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
699 v->pquantizer = pqindex < 9;
700 if (v->quantizer_mode == QUANT_NON_UNIFORM)
702 v->pqindex = pqindex;
704 v->halfpq = get_bits1(gb);
707 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
708 v->pquantizer = get_bits1(gb);
710 if (v->extended_mv == 1)
711 v->mvrange = get_unary(gb, 0, 3);
712 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
713 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
714 v->range_x = 1 << (v->k_x - 1);
715 v->range_y = 1 << (v->k_y - 1);
716 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
717 v->respic = get_bits(gb, 2);
719 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
720 v->x8_type = get_bits1(gb);
723 av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
724 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
725 pqindex, v->pq, v->halfpq, v->rangeredfrm);
727 if (v->first_pic_header_flag)
730 switch (v->s.pict_type) {
731 case AV_PICTURE_TYPE_P:
732 if (v->pq < 5) v->tt_index = 0;
733 else if (v->pq < 13) v->tt_index = 1;
734 else v->tt_index = 2;
736 lowquant = (v->pq > 12) ? 0 : 1;
737 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
738 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
739 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
740 v->lumscale = get_bits(gb, 6);
741 v->lumshift = get_bits(gb, 6);
743 /* fill lookup tables for intensity compensation */
744 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
745 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
747 v->qs_last = v->s.quarter_sample;
748 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
749 v->s.quarter_sample = 0;
750 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
751 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
752 v->s.quarter_sample = 0;
754 v->s.quarter_sample = 1;
756 v->s.quarter_sample = 1;
757 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));
759 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
760 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
761 v->mv_mode == MV_PMODE_MIXED_MV) {
762 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
765 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
766 "Imode: %i, Invert: %i\n", status>>1, status&1);
768 v->mv_type_is_raw = 0;
769 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
771 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
774 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
775 "Imode: %i, Invert: %i\n", status>>1, status&1);
777 /* Hopefully this is correct for P frames */
778 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
779 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
782 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
783 vop_dquant_decoding(v);
786 v->ttfrm = 0; //FIXME Is that so ?
787 if (v->vstransform) {
788 v->ttmbf = get_bits1(gb);
790 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
797 case AV_PICTURE_TYPE_B:
798 if (v->pq < 5) v->tt_index = 0;
799 else if (v->pq < 13) v->tt_index = 1;
800 else v->tt_index = 2;
802 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
803 v->qs_last = v->s.quarter_sample;
804 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
805 v->s.mspel = v->s.quarter_sample;
807 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
810 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
811 "Imode: %i, Invert: %i\n", status>>1, status&1);
812 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
815 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
816 "Imode: %i, Invert: %i\n", status>>1, status&1);
818 v->s.mv_table_index = get_bits(gb, 2);
819 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
822 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
823 vop_dquant_decoding(v);
827 if (v->vstransform) {
828 v->ttmbf = get_bits1(gb);
830 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
841 v->c_ac_table_index = decode012(gb);
842 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
843 v->y_ac_table_index = decode012(gb);
846 v->s.dc_table_index = get_bits1(gb);
849 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
850 v->s.pict_type = AV_PICTURE_TYPE_B;
856 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
858 int pqindex, lowquant;
860 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
864 v->p_frame_skipped = 0;
865 if (v->second_field) {
866 if(v->fcm!=2 || v->field_mode!=1)
868 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
870 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
871 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
872 if (!v->pic_header_flag)
873 goto parse_common_info;
880 if (fcm == ILACE_FIELD)
886 if (!v->first_pic_header_flag && v->field_mode != field_mode)
887 return AVERROR_INVALIDDATA;
888 v->field_mode = field_mode;
891 av_assert0( v->s.mb_height == v->s.height + 15 >> 4
892 || v->s.mb_height == FFALIGN(v->s.height + 15 >> 4, 2));
894 v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
895 v->fptype = get_bits(gb, 3);
896 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
897 if (v->fptype & 4) // B-picture
898 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
901 v->s.mb_height = v->s.height + 15 >> 4;
902 switch (get_unary(gb, 0, 4)) {
904 v->s.pict_type = AV_PICTURE_TYPE_P;
907 v->s.pict_type = AV_PICTURE_TYPE_B;
910 v->s.pict_type = AV_PICTURE_TYPE_I;
913 v->s.pict_type = AV_PICTURE_TYPE_BI;
916 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
917 v->p_frame_skipped = 1;
924 if (!v->interlace || v->psf) {
925 v->rptfrm = get_bits(gb, 2);
927 v->tff = get_bits1(gb);
928 v->rff = get_bits1(gb);
933 if (v->panscanflag) {
934 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
937 if (v->p_frame_skipped) {
940 v->rnd = get_bits1(gb);
942 v->uvsamp = get_bits1(gb);
943 if(!ff_vc1_bfraction_vlc.table)
944 return 0; //parsing only, vlc tables havnt been allocated
946 if (!v->refdist_flag)
948 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
949 v->refdist = get_bits(gb, 2);
951 v->refdist += get_unary(gb, 0, 16);
953 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
954 if (read_bfraction(v, gb) < 0)
955 return AVERROR_INVALIDDATA;
956 v->frfd = (v->bfraction * v->refdist) >> 8;
957 v->brfd = v->refdist - v->frfd - 1;
961 goto parse_common_info;
963 if (v->fcm == PROGRESSIVE) {
965 v->interpfrm = get_bits1(gb);
966 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
967 if (read_bfraction(v, gb) < 0)
968 return AVERROR_INVALIDDATA;
969 if (v->bfraction == 0) {
970 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
977 v->cur_field_type = !(v->tff ^ v->second_field);
978 pqindex = get_bits(gb, 5);
981 v->pqindex = pqindex;
982 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
983 v->pq = ff_vc1_pquant_table[0][pqindex];
985 v->pq = ff_vc1_pquant_table[1][pqindex];
988 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
989 v->pquantizer = pqindex < 9;
990 if (v->quantizer_mode == QUANT_NON_UNIFORM)
992 v->pqindex = pqindex;
994 v->halfpq = get_bits1(gb);
997 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
998 v->pquantizer = get_bits1(gb);
1000 v->postproc = get_bits(gb, 2);
1005 if (v->first_pic_header_flag)
1008 switch (v->s.pict_type) {
1009 case AV_PICTURE_TYPE_I:
1010 case AV_PICTURE_TYPE_BI:
1011 if (v->fcm == ILACE_FRAME) { //interlace frame picture
1012 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
1015 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1016 "Imode: %i, Invert: %i\n", status>>1, status&1);
1018 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1021 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1022 "Imode: %i, Invert: %i\n", status>>1, status&1);
1023 v->condover = CONDOVER_NONE;
1024 if (v->overlap && v->pq <= 8) {
1025 v->condover = decode012(gb);
1026 if (v->condover == CONDOVER_SELECT) {
1027 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1030 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1031 "Imode: %i, Invert: %i\n", status>>1, status&1);
1035 case AV_PICTURE_TYPE_P:
1036 if (v->field_mode) {
1037 v->numref = get_bits1(gb);
1039 v->reffield = get_bits1(gb);
1040 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1044 v->mvrange = get_unary(gb, 0, 3);
1048 if (v->extended_dmv)
1049 v->dmvrange = get_unary(gb, 0, 3);
1052 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1053 v->fourmvswitch = get_bits1(gb);
1054 v->intcomp = get_bits1(gb);
1056 v->lumscale = get_bits(gb, 6);
1057 v->lumshift = get_bits(gb, 6);
1058 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1059 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1062 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1063 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1064 "Imode: %i, Invert: %i\n", status>>1, status&1);
1065 mbmodetab = get_bits(gb, 2);
1066 if (v->fourmvswitch)
1067 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1069 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1070 imvtab = get_bits(gb, 2);
1071 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1072 // interlaced p-picture cbpcy range is [1, 63]
1073 icbptab = get_bits(gb, 3);
1074 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1075 twomvbptab = get_bits(gb, 2);
1076 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1077 if (v->fourmvswitch) {
1078 fourmvbptab = get_bits(gb, 2);
1079 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1083 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1084 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1085 v->range_x = 1 << (v->k_x - 1);
1086 v->range_y = 1 << (v->k_y - 1);
1090 else if (v->pq < 13)
1094 if (v->fcm != ILACE_FRAME) {
1096 mvmode = get_unary(gb, 1, 4);
1097 lowquant = (v->pq > 12) ? 0 : 1;
1098 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1099 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1101 mvmode2 = get_unary(gb, 1, 3);
1102 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1103 if (v->field_mode) {
1104 v->intcompfield = decode210(gb) ^ 3;
1106 v->intcompfield = 3;
1108 v->lumscale2 = v->lumscale = 32;
1109 v->lumshift2 = v->lumshift = 0;
1110 if (v->intcompfield & 1) {
1111 v->lumscale = get_bits(gb, 6);
1112 v->lumshift = get_bits(gb, 6);
1114 if ((v->intcompfield & 2) && v->field_mode) {
1115 v->lumscale2 = get_bits(gb, 6);
1116 v->lumshift2 = get_bits(gb, 6);
1117 } else if(!v->field_mode) {
1118 v->lumscale2 = v->lumscale;
1119 v->lumshift2 = v->lumshift;
1121 if (v->field_mode && v->second_field) {
1122 if (v->cur_field_type) {
1123 INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1124 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1126 INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1127 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1129 v->next_use_ic = *v->curr_use_ic = 1;
1131 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1132 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1136 v->qs_last = v->s.quarter_sample;
1137 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1138 v->s.quarter_sample = 0;
1139 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1140 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1141 v->s.quarter_sample = 0;
1143 v->s.quarter_sample = 1;
1145 v->s.quarter_sample = 1;
1146 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1147 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1148 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1150 if (v->fcm == PROGRESSIVE) { // progressive
1151 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1152 v->mv_mode2 == MV_PMODE_MIXED_MV)
1153 || v->mv_mode == MV_PMODE_MIXED_MV) {
1154 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1157 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1158 "Imode: %i, Invert: %i\n", status>>1, status&1);
1160 v->mv_type_is_raw = 0;
1161 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1163 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1166 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1167 "Imode: %i, Invert: %i\n", status>>1, status&1);
1169 /* Hopefully this is correct for P frames */
1170 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1171 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1172 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1173 v->qs_last = v->s.quarter_sample;
1174 v->s.quarter_sample = 1;
1176 } else { // field interlaced
1177 mbmodetab = get_bits(gb, 3);
1178 imvtab = get_bits(gb, 2 + v->numref);
1180 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1182 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1183 icbptab = get_bits(gb, 3);
1184 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1185 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1186 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1187 fourmvbptab = get_bits(gb, 2);
1188 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1189 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1191 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1195 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1196 vop_dquant_decoding(v);
1199 v->ttfrm = 0; //FIXME Is that so ?
1200 if (v->vstransform) {
1201 v->ttmbf = get_bits1(gb);
1203 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1210 case AV_PICTURE_TYPE_B:
1211 if (v->fcm == ILACE_FRAME) {
1212 if (read_bfraction(v, gb) < 0)
1213 return AVERROR_INVALIDDATA;
1214 if (v->bfraction == 0) {
1219 v->mvrange = get_unary(gb, 0, 3);
1222 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1223 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1224 v->range_x = 1 << (v->k_x - 1);
1225 v->range_y = 1 << (v->k_y - 1);
1229 else if (v->pq < 13)
1234 if (v->field_mode) {
1236 av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1237 if (v->extended_dmv)
1238 v->dmvrange = get_unary(gb, 0, 3);
1239 mvmode = get_unary(gb, 1, 3);
1240 lowquant = (v->pq > 12) ? 0 : 1;
1241 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1242 v->qs_last = v->s.quarter_sample;
1243 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1244 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1245 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1248 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1249 "Imode: %i, Invert: %i\n", status>>1, status&1);
1250 mbmodetab = get_bits(gb, 3);
1251 if (v->mv_mode == MV_PMODE_MIXED_MV)
1252 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1254 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1255 imvtab = get_bits(gb, 3);
1256 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1257 icbptab = get_bits(gb, 3);
1258 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1259 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1260 fourmvbptab = get_bits(gb, 2);
1261 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1263 v->numref = 1; // interlaced field B pictures are always 2-ref
1264 } else if (v->fcm == ILACE_FRAME) {
1265 if (v->extended_dmv)
1266 v->dmvrange = get_unary(gb, 0, 3);
1267 if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1268 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1270 v->mv_mode = MV_PMODE_1MV;
1271 v->fourmvswitch = 0;
1272 v->qs_last = v->s.quarter_sample;
1273 v->s.quarter_sample = 1;
1275 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1278 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1279 "Imode: %i, Invert: %i\n", status>>1, status&1);
1280 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1283 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1284 "Imode: %i, Invert: %i\n", status>>1, status&1);
1285 mbmodetab = get_bits(gb, 2);
1286 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1287 imvtab = get_bits(gb, 2);
1288 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1289 // interlaced p/b-picture cbpcy range is [1, 63]
1290 icbptab = get_bits(gb, 3);
1291 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1292 twomvbptab = get_bits(gb, 2);
1293 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1294 fourmvbptab = get_bits(gb, 2);
1295 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1297 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1298 v->qs_last = v->s.quarter_sample;
1299 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1300 v->s.mspel = v->s.quarter_sample;
1301 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1304 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1305 "Imode: %i, Invert: %i\n", status>>1, status&1);
1306 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1309 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1310 "Imode: %i, Invert: %i\n", status>>1, status&1);
1311 v->s.mv_table_index = get_bits(gb, 2);
1312 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1316 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1317 vop_dquant_decoding(v);
1321 if (v->vstransform) {
1322 v->ttmbf = get_bits1(gb);
1324 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1333 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1339 v->c_ac_table_index = decode012(gb);
1340 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1341 v->y_ac_table_index = decode012(gb);
1344 v->s.dc_table_index = get_bits1(gb);
1345 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1347 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1348 vop_dquant_decoding(v);
1352 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1353 v->s.pict_type = AV_PICTURE_TYPE_B;
1359 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1361 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1362 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1363 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1364 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1365 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1366 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1367 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1368 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1369 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1370 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1371 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1372 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1373 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1374 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1375 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1376 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1377 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1378 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1379 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1380 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1381 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1382 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1383 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1384 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1385 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1386 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1387 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1388 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1389 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1390 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1391 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1394 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1395 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1396 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1397 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1398 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1399 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1400 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1401 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1402 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1403 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1404 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1405 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1406 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1407 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1408 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1409 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1410 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1411 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1412 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1413 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1414 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1415 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1416 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1417 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1418 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1419 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1420 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1421 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1425 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1426 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1427 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1428 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1429 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1430 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1431 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1432 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1433 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1434 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1435 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1436 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1437 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1438 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1439 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1440 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1441 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1442 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1443 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1444 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1445 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1446 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1450 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1451 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1452 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1453 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1454 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1455 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1456 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1457 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1458 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1459 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1460 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1461 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1462 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1463 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1464 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1465 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1466 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1467 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1468 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1469 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1470 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1471 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1472 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1473 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1474 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1477 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1478 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1479 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1480 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1481 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1482 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1483 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1484 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1485 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1486 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1487 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1488 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1489 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1490 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1491 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1492 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1493 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1497 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1498 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1499 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1500 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1501 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1502 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1503 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1504 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1505 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1506 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1507 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1508 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1509 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1510 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1511 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1512 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1513 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1517 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1518 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1519 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1520 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1521 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1522 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1523 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1524 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1525 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1526 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1527 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1528 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1529 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1530 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1531 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1532 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1533 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1534 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1535 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1536 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1537 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1538 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1539 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1540 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1541 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1542 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1543 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1547 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1548 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1549 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1550 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1551 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1552 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1553 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1554 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1555 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1556 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1557 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1558 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1559 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1560 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1561 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1562 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1563 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1564 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1565 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1566 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1567 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1568 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1569 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1570 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1571 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1572 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1573 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1574 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1575 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1580 static const uint16_t vlc_offs[] = {
1581 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1582 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1583 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1584 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1585 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1586 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1587 31714, 31746, 31778, 32306, 32340, 32372
1591 * Init VC-1 specific tables and VC1Context members
1592 * @param v The VC1Context to initialize
1595 av_cold int ff_vc1_init_common(VC1Context *v)
1597 static int done = 0;
1599 static VLC_TYPE vlc_table[32372][2];
1601 v->hrd_rate = v->hrd_buffer = NULL;
1605 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1606 ff_vc1_bfraction_bits, 1, 1,
1607 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1608 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1609 ff_vc1_norm2_bits, 1, 1,
1610 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1611 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1612 ff_vc1_norm6_bits, 1, 1,
1613 ff_vc1_norm6_codes, 2, 2, 556);
1614 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1615 ff_vc1_imode_bits, 1, 1,
1616 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1617 for (i = 0; i < 3; i++) {
1618 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1619 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1620 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1621 ff_vc1_ttmb_bits[i], 1, 1,
1622 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1623 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1624 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1625 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1626 ff_vc1_ttblk_bits[i], 1, 1,
1627 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1628 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1629 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1630 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1631 ff_vc1_subblkpat_bits[i], 1, 1,
1632 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1634 for (i = 0; i < 4; i++) {
1635 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1636 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1637 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1638 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1639 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1640 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1641 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1642 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1643 ff_vc1_cbpcy_p_bits[i], 1, 1,
1644 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1645 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1646 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1647 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1648 ff_vc1_mv_diff_bits[i], 1, 1,
1649 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1651 for (i = 0; i < 8; i++) {
1652 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1653 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1654 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1655 &vc1_ac_tables[i][0][1], 8, 4,
1656 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1657 /* initialize interlaced MVDATA tables (2-Ref) */
1658 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1659 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1660 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1661 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1662 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1664 for (i = 0; i < 4; i++) {
1665 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1666 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1667 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1668 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1669 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1670 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1671 /* initialize NON-4MV MBMODE VLC tables for the same */
1672 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1673 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1674 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1675 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1676 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1677 /* initialize interlaced MVDATA tables (1-Ref) */
1678 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1679 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1680 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1681 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1682 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1684 for (i = 0; i < 4; i++) {
1685 /* Initialize 2MV Block pattern VLC tables */
1686 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1687 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1688 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1689 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1690 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1692 for (i = 0; i < 8; i++) {
1693 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1694 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1695 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1696 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1697 ff_vc1_icbpcy_p_bits[i], 1, 1,
1698 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1699 /* Initialize interlaced field picture MBMODE VLC tables */
1700 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1701 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1702 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1703 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1704 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1705 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1706 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1707 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1708 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1709 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1714 /* Other defaults */
1716 v->mvrange = 0; /* 7.1.1.18, p80 */
1718 ff_vc1dsp_init(&v->vc1dsp);