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"
40 /***********************************************************************/
42 * @name VC-1 Bitplane decoding
47 /** Decode rows by checking if they are skipped
48 * @param plane Buffer to store decoded bits
49 * @param[in] width Width of this buffer
50 * @param[in] height Height of this buffer
51 * @param[in] stride of this buffer
53 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
58 for (y = 0; y < height; y++) {
59 if (!get_bits1(gb)) //rowskip
60 memset(plane, 0, width);
62 for (x = 0; x < width; x++)
63 plane[x] = get_bits1(gb);
68 /** Decode columns by checking if they are skipped
69 * @param plane Buffer to store decoded bits
70 * @param[in] width Width of this buffer
71 * @param[in] height Height of this buffer
72 * @param[in] stride of this buffer
73 * @todo FIXME: Optimize
75 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
80 for (x = 0; x < width; x++) {
81 if (!get_bits1(gb)) //colskip
82 for (y = 0; y < height; y++)
85 for (y = 0; y < height; y++)
86 plane[y*stride] = get_bits1(gb);
91 /** Decode a bitplane's bits
92 * @param data bitplane where to store the decode bits
93 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
94 * @param v VC-1 context for bit reading and logging
96 * @todo FIXME: Optimize
98 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
100 GetBitContext *gb = &v->s.gb;
102 int imode, x, y, code, offset;
103 uint8_t invert, *planep = data;
104 int width, height, stride;
106 width = v->s.mb_width;
107 height = v->s.mb_height >> v->field_mode;
108 stride = v->s.mb_stride;
109 invert = get_bits1(gb);
110 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
115 //Data is actually read in the MB layer (same for all tests == "raw")
116 *raw_flag = 1; //invert ignored
120 if ((height * width) & 1) {
121 *planep++ = get_bits1(gb);
123 if (offset == width) {
125 planep += stride - width;
130 // decode bitplane as one long line
131 for (; y < height * width; y += 2) {
132 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
133 *planep++ = code & 1;
135 if (offset == width) {
137 planep += stride - width;
139 *planep++ = code >> 1;
141 if (offset == width) {
143 planep += stride - width;
149 if (!(height % 3) && (width % 3)) { // use 2x3 decoding
150 for (y = 0; y < height; y += 3) {
151 for (x = width & 1; x < width; x += 2) {
152 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
154 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
157 planep[x + 0] = (code >> 0) & 1;
158 planep[x + 1] = (code >> 1) & 1;
159 planep[x + 0 + stride] = (code >> 2) & 1;
160 planep[x + 1 + stride] = (code >> 3) & 1;
161 planep[x + 0 + stride * 2] = (code >> 4) & 1;
162 planep[x + 1 + stride * 2] = (code >> 5) & 1;
164 planep += stride * 3;
167 decode_colskip(data, 1, height, stride, &v->s.gb);
169 planep += (height & 1) * stride;
170 for (y = height & 1; y < height; y += 2) {
171 for (x = width % 3; x < width; x += 3) {
172 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
174 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
177 planep[x + 0] = (code >> 0) & 1;
178 planep[x + 1] = (code >> 1) & 1;
179 planep[x + 2] = (code >> 2) & 1;
180 planep[x + 0 + stride] = (code >> 3) & 1;
181 planep[x + 1 + stride] = (code >> 4) & 1;
182 planep[x + 2 + stride] = (code >> 5) & 1;
184 planep += stride * 2;
188 decode_colskip(data, x, height, stride, &v->s.gb);
190 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
194 decode_rowskip(data, width, height, stride, &v->s.gb);
197 decode_colskip(data, width, height, stride, &v->s.gb);
203 /* Applying diff operator */
204 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
207 for (x = 1; x < width; x++)
208 planep[x] ^= planep[x-1];
209 for (y = 1; y < height; y++) {
211 planep[0] ^= planep[-stride];
212 for (x = 1; x < width; x++) {
213 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
214 else planep[x] ^= planep[x-1];
219 for (x = 0; x < stride * height; x++)
220 planep[x] = !planep[x]; //FIXME stride
222 return (imode << 1) + invert;
225 /** @} */ //Bitplane group
227 /***********************************************************************/
228 /** VOP Dquant decoding
229 * @param v VC-1 Context
231 static int vop_dquant_decoding(VC1Context *v)
233 GetBitContext *gb = &v->s.gb;
237 if (v->dquant == 2) {
238 pqdiff = get_bits(gb, 3);
240 v->altpq = get_bits(gb, 5);
242 v->altpq = v->pq + pqdiff + 1;
244 v->dquantfrm = get_bits1(gb);
246 v->dqprofile = get_bits(gb, 2);
247 switch (v->dqprofile) {
248 case DQPROFILE_SINGLE_EDGE:
249 case DQPROFILE_DOUBLE_EDGES:
250 v->dqsbedge = get_bits(gb, 2);
252 case DQPROFILE_ALL_MBS:
253 v->dqbilevel = get_bits1(gb);
259 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
260 pqdiff = get_bits(gb, 3);
262 v->altpq = get_bits(gb, 5);
264 v->altpq = v->pq + pqdiff + 1;
271 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
274 * Decode Simple/Main Profiles sequence header
275 * @see Figure 7-8, p16-17
276 * @param avctx Codec context
277 * @param gb GetBit context initialized from Codec context extra_data
280 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
282 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
283 v->profile = get_bits(gb, 2);
284 if (v->profile == PROFILE_COMPLEX) {
285 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
288 if (v->profile == PROFILE_ADVANCED) {
289 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
290 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
291 return decode_sequence_header_adv(v, gb);
294 v->zz_8x4 = ff_wmv2_scantableA;
295 v->zz_4x8 = ff_wmv2_scantableB;
296 v->res_y411 = get_bits1(gb);
297 v->res_sprite = get_bits1(gb);
299 av_log(avctx, AV_LOG_ERROR,
300 "Old interlaced mode is not supported\n");
306 v->frmrtq_postproc = get_bits(gb, 3); //common
307 // (bitrate-32kbps)/64kbps
308 v->bitrtq_postproc = get_bits(gb, 5); //common
309 v->s.loop_filter = get_bits1(gb); //common
310 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
311 av_log(avctx, AV_LOG_ERROR,
312 "LOOPFILTER shall not be enabled in Simple Profile\n");
314 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
315 v->s.loop_filter = 0;
317 v->res_x8 = get_bits1(gb); //reserved
318 v->multires = get_bits1(gb);
319 v->res_fasttx = get_bits1(gb);
320 if (!v->res_fasttx) {
321 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;
322 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
323 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
324 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
325 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
326 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
327 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
328 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
331 v->fastuvmc = get_bits1(gb); //common
332 if (!v->profile && !v->fastuvmc) {
333 av_log(avctx, AV_LOG_ERROR,
334 "FASTUVMC unavailable in Simple Profile\n");
337 v->extended_mv = get_bits1(gb); //common
338 if (!v->profile && v->extended_mv)
340 av_log(avctx, AV_LOG_ERROR,
341 "Extended MVs unavailable in Simple Profile\n");
344 v->dquant = get_bits(gb, 2); //common
345 v->vstransform = get_bits1(gb); //common
347 v->res_transtab = get_bits1(gb);
350 av_log(avctx, AV_LOG_ERROR,
351 "1 for reserved RES_TRANSTAB is forbidden\n");
355 v->overlap = get_bits1(gb); //common
357 v->resync_marker = get_bits1(gb);
358 v->rangered = get_bits1(gb);
359 if (v->rangered && v->profile == PROFILE_SIMPLE) {
360 av_log(avctx, AV_LOG_INFO,
361 "RANGERED should be set to 0 in Simple Profile\n");
364 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
365 v->quantizer_mode = get_bits(gb, 2); //common
367 v->finterpflag = get_bits1(gb); //common
370 int w = get_bits(gb, 11);
371 int h = get_bits(gb, 11);
372 int ret = ff_set_dimensions(v->s.avctx, w, h);
374 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
377 skip_bits(gb, 5); //frame rate
378 v->res_x8 = get_bits1(gb);
379 if (get_bits1(gb)) { // something to do with DC VLC selection
380 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
383 skip_bits(gb, 3); //slice code
386 v->res_rtm_flag = get_bits1(gb); //reserved
388 if (!v->res_rtm_flag) {
389 av_log(avctx, AV_LOG_ERROR,
390 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
393 //TODO: figure out what they mean (always 0x402F)
396 av_log(avctx, AV_LOG_DEBUG,
397 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
398 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
399 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
400 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
401 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
402 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
403 v->rangered, v->vstransform, v->overlap, v->resync_marker,
404 v->dquant, v->quantizer_mode, avctx->max_b_frames);
408 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
411 v->level = get_bits(gb, 3);
413 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
415 v->chromaformat = get_bits(gb, 2);
416 if (v->chromaformat != 1) {
417 av_log(v->s.avctx, AV_LOG_ERROR,
418 "Only 4:2:0 chroma format supported\n");
423 v->frmrtq_postproc = get_bits(gb, 3); //common
424 // (bitrate-32kbps)/64kbps
425 v->bitrtq_postproc = get_bits(gb, 5); //common
426 v->postprocflag = get_bits1(gb); //common
428 v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
429 v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
430 v->broadcast = get_bits1(gb);
431 v->interlace = get_bits1(gb);
432 v->tfcntrflag = get_bits1(gb);
433 v->finterpflag = get_bits1(gb);
434 skip_bits1(gb); // reserved
436 av_log(v->s.avctx, AV_LOG_DEBUG,
437 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
438 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
439 "TFCTRflag=%i, FINTERPflag=%i\n",
440 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
441 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
442 v->tfcntrflag, v->finterpflag);
444 v->psf = get_bits1(gb);
445 if (v->psf) { //PsF, 6.1.13
446 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
449 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
450 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
452 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
453 w = get_bits(gb, 14) + 1;
454 h = get_bits(gb, 14) + 1;
455 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
457 ar = get_bits(gb, 4);
459 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
460 } else if (ar == 15) {
461 w = get_bits(gb, 8) + 1;
462 h = get_bits(gb, 8) + 1;
463 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
465 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
466 &v->s.avctx->sample_aspect_ratio.den,
467 v->s.avctx->height * w,
468 v->s.avctx->width * h,
471 ff_set_sar(v->s.avctx, v->s.avctx->sample_aspect_ratio);
472 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
473 v->s.avctx->sample_aspect_ratio.num,
474 v->s.avctx->sample_aspect_ratio.den);
476 if (get_bits1(gb)) { //framerate stuff
478 v->s.avctx->framerate.den = 32;
479 v->s.avctx->framerate.num = get_bits(gb, 16) + 1;
482 nr = get_bits(gb, 8);
483 dr = get_bits(gb, 4);
484 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
485 v->s.avctx->framerate.den = ff_vc1_fps_dr[dr - 1];
486 v->s.avctx->framerate.num = ff_vc1_fps_nr[nr - 1] * 1000;
489 if (v->broadcast) { // Pulldown may be present
490 v->s.avctx->ticks_per_frame = 2;
495 v->color_prim = get_bits(gb, 8);
496 v->transfer_char = get_bits(gb, 8);
497 v->matrix_coef = get_bits(gb, 8);
501 v->hrd_param_flag = get_bits1(gb);
502 if (v->hrd_param_flag) {
504 v->hrd_num_leaky_buckets = get_bits(gb, 5);
505 skip_bits(gb, 4); //bitrate exponent
506 skip_bits(gb, 4); //buffer size exponent
507 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
508 skip_bits(gb, 16); //hrd_rate[n]
509 skip_bits(gb, 16); //hrd_buffer[n]
515 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
521 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
522 v->broken_link = get_bits1(gb);
523 v->closed_entry = get_bits1(gb);
524 v->panscanflag = get_bits1(gb);
525 v->refdist_flag = get_bits1(gb);
526 v->s.loop_filter = get_bits1(gb);
527 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
528 v->s.loop_filter = 0;
529 v->fastuvmc = get_bits1(gb);
530 v->extended_mv = get_bits1(gb);
531 v->dquant = get_bits(gb, 2);
532 v->vstransform = get_bits1(gb);
533 v->overlap = get_bits1(gb);
534 v->quantizer_mode = get_bits(gb, 2);
536 if (v->hrd_param_flag) {
537 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
538 skip_bits(gb, 8); //hrd_full[n]
543 w = (get_bits(gb, 12)+1)<<1;
544 h = (get_bits(gb, 12)+1)<<1;
546 w = v->max_coded_width;
547 h = v->max_coded_height;
549 if ((ret = ff_set_dimensions(avctx, w, h)) < 0) {
550 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
555 v->extended_dmv = get_bits1(gb);
556 if ((v->range_mapy_flag = get_bits1(gb))) {
557 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
558 v->range_mapy = get_bits(gb, 3);
560 if ((v->range_mapuv_flag = get_bits1(gb))) {
561 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
562 v->range_mapuv = get_bits(gb, 3);
565 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
566 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
567 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
568 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
569 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
570 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
575 /* fill lookup tables for intensity compensation */
576 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \
577 int scale, shift, i; \
580 shift = (255 - lumshift * 2) << 6; \
584 scale = lumscale + 32; \
586 shift = (lumshift - 64) << 6; \
588 shift = lumshift << 6; \
590 for (i = 0; i < 256; i++) { \
591 int iy = chain ? luty[i] : i; \
592 int iu = chain ? lutuv[i] : i; \
593 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
594 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
598 static void rotate_luts(VC1Context *v)
600 #define ROTATE(DEF, L, N, C, A) do { \
601 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
605 memcpy(&tmp, L , sizeof(tmp)); \
606 memcpy(L , N , sizeof(tmp)); \
607 memcpy(N , &tmp, sizeof(tmp)); \
612 ROTATE(int tmp, &v->last_use_ic, &v->next_use_ic, v->curr_use_ic, &v->aux_use_ic);
613 ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
614 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
616 INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
617 INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
621 static int read_bfraction(VC1Context *v, GetBitContext* gb) {
622 int bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
624 if (bfraction_lut_index == 21 || bfraction_lut_index < 0) {
625 av_log(v->s.avctx, AV_LOG_ERROR, "bfraction invalid\n");
626 return AVERROR_INVALIDDATA;
628 v->bfraction_lut_index = bfraction_lut_index;
629 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
633 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
635 int pqindex, lowquant, status;
640 v->interpfrm = get_bits1(gb);
641 if (!v->s.avctx->codec)
643 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
646 v->multires = get_bits(gb, 2) == 1;
648 skip_bits(gb, 2); //framecnt unused
651 v->rangeredfrm = get_bits1(gb);
652 v->s.pict_type = get_bits1(gb);
653 if (v->s.avctx->max_b_frames) {
654 if (!v->s.pict_type) {
656 v->s.pict_type = AV_PICTURE_TYPE_I;
658 v->s.pict_type = AV_PICTURE_TYPE_B;
660 v->s.pict_type = AV_PICTURE_TYPE_P;
662 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
665 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
666 if (read_bfraction(v, gb) < 0)
667 return AVERROR_INVALIDDATA;
668 if (v->bfraction == 0) {
669 v->s.pict_type = AV_PICTURE_TYPE_BI;
672 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
673 skip_bits(gb, 7); // skip buffer fullness
679 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
681 if (v->s.pict_type == AV_PICTURE_TYPE_P)
684 /* Quantizer stuff */
685 pqindex = get_bits(gb, 5);
688 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
689 v->pq = ff_vc1_pquant_table[0][pqindex];
691 v->pq = ff_vc1_pquant_table[1][pqindex];
694 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
695 v->pquantizer = pqindex < 9;
696 if (v->quantizer_mode == QUANT_NON_UNIFORM)
698 v->pqindex = pqindex;
700 v->halfpq = get_bits1(gb);
703 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
704 v->pquantizer = get_bits1(gb);
706 if (v->extended_mv == 1)
707 v->mvrange = get_unary(gb, 0, 3);
708 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
709 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
710 v->range_x = 1 << (v->k_x - 1);
711 v->range_y = 1 << (v->k_y - 1);
712 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
713 v->respic = get_bits(gb, 2);
715 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
716 v->x8_type = get_bits1(gb);
719 av_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
720 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
721 pqindex, v->pq, v->halfpq, v->rangeredfrm);
723 if (v->first_pic_header_flag)
726 switch (v->s.pict_type) {
727 case AV_PICTURE_TYPE_P:
728 if (v->pq < 5) v->tt_index = 0;
729 else if (v->pq < 13) v->tt_index = 1;
730 else v->tt_index = 2;
732 lowquant = (v->pq > 12) ? 0 : 1;
733 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
734 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
735 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
736 v->lumscale = get_bits(gb, 6);
737 v->lumshift = get_bits(gb, 6);
739 /* fill lookup tables for intensity compensation */
740 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
741 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
743 v->qs_last = v->s.quarter_sample;
744 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
745 v->s.quarter_sample = 0;
746 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
747 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
748 v->s.quarter_sample = 0;
750 v->s.quarter_sample = 1;
752 v->s.quarter_sample = 1;
753 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));
755 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
756 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
757 v->mv_mode == MV_PMODE_MIXED_MV) {
758 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
761 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
762 "Imode: %i, Invert: %i\n", status>>1, status&1);
764 v->mv_type_is_raw = 0;
765 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
767 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
770 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
771 "Imode: %i, Invert: %i\n", status>>1, status&1);
773 /* Hopefully this is correct for P frames */
774 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
775 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
778 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
779 vop_dquant_decoding(v);
782 v->ttfrm = 0; //FIXME Is that so ?
783 if (v->vstransform) {
784 v->ttmbf = get_bits1(gb);
786 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
793 case AV_PICTURE_TYPE_B:
794 if (v->pq < 5) v->tt_index = 0;
795 else if (v->pq < 13) v->tt_index = 1;
796 else v->tt_index = 2;
798 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
799 v->qs_last = v->s.quarter_sample;
800 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
801 v->s.mspel = v->s.quarter_sample;
803 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
806 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
807 "Imode: %i, Invert: %i\n", status>>1, status&1);
808 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
811 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
812 "Imode: %i, Invert: %i\n", status>>1, status&1);
814 v->s.mv_table_index = get_bits(gb, 2);
815 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
818 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
819 vop_dquant_decoding(v);
823 if (v->vstransform) {
824 v->ttmbf = get_bits1(gb);
826 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
837 v->c_ac_table_index = decode012(gb);
838 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
839 v->y_ac_table_index = decode012(gb);
842 v->s.dc_table_index = get_bits1(gb);
845 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
846 v->s.pict_type = AV_PICTURE_TYPE_B;
852 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
854 int pqindex, lowquant;
856 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
860 v->p_frame_skipped = 0;
861 if (v->second_field) {
862 if(v->fcm!=2 || v->field_mode!=1)
864 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
866 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
867 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
868 if (!v->pic_header_flag)
869 goto parse_common_info;
876 if (fcm == ILACE_FIELD)
882 if (!v->first_pic_header_flag && v->field_mode != field_mode)
883 return AVERROR_INVALIDDATA;
884 v->field_mode = field_mode;
887 av_assert0( v->s.mb_height == v->s.height + 15 >> 4
888 || v->s.mb_height == FFALIGN(v->s.height + 15 >> 4, 2));
890 v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
891 v->fptype = get_bits(gb, 3);
892 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
893 if (v->fptype & 4) // B-picture
894 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
897 v->s.mb_height = v->s.height + 15 >> 4;
898 switch (get_unary(gb, 0, 4)) {
900 v->s.pict_type = AV_PICTURE_TYPE_P;
903 v->s.pict_type = AV_PICTURE_TYPE_B;
906 v->s.pict_type = AV_PICTURE_TYPE_I;
909 v->s.pict_type = AV_PICTURE_TYPE_BI;
912 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
913 v->p_frame_skipped = 1;
920 if (!v->interlace || v->psf) {
921 v->rptfrm = get_bits(gb, 2);
923 v->tff = get_bits1(gb);
924 v->rff = get_bits1(gb);
929 if (v->panscanflag) {
930 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
933 if (v->p_frame_skipped) {
936 v->rnd = get_bits1(gb);
938 v->uvsamp = get_bits1(gb);
939 if(!ff_vc1_bfraction_vlc.table)
940 return 0; //parsing only, vlc tables havnt been allocated
942 if (!v->refdist_flag)
944 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
945 v->refdist = get_bits(gb, 2);
947 v->refdist += get_unary(gb, 0, 16);
949 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
950 if (read_bfraction(v, gb) < 0)
951 return AVERROR_INVALIDDATA;
952 v->frfd = (v->bfraction * v->refdist) >> 8;
953 v->brfd = v->refdist - v->frfd - 1;
957 goto parse_common_info;
959 if (v->fcm == PROGRESSIVE) {
961 v->interpfrm = get_bits1(gb);
962 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
963 if (read_bfraction(v, gb) < 0)
964 return AVERROR_INVALIDDATA;
965 if (v->bfraction == 0) {
966 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
973 v->cur_field_type = !(v->tff ^ v->second_field);
974 pqindex = get_bits(gb, 5);
977 v->pqindex = pqindex;
978 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
979 v->pq = ff_vc1_pquant_table[0][pqindex];
981 v->pq = ff_vc1_pquant_table[1][pqindex];
984 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
985 v->pquantizer = pqindex < 9;
986 if (v->quantizer_mode == QUANT_NON_UNIFORM)
988 v->pqindex = pqindex;
990 v->halfpq = get_bits1(gb);
993 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
994 v->pquantizer = get_bits1(gb);
996 v->postproc = get_bits(gb, 2);
1001 if (v->first_pic_header_flag)
1004 switch (v->s.pict_type) {
1005 case AV_PICTURE_TYPE_I:
1006 case AV_PICTURE_TYPE_BI:
1007 if (v->fcm == ILACE_FRAME) { //interlace frame picture
1008 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
1011 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1012 "Imode: %i, Invert: %i\n", status>>1, status&1);
1014 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1017 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1018 "Imode: %i, Invert: %i\n", status>>1, status&1);
1019 v->condover = CONDOVER_NONE;
1020 if (v->overlap && v->pq <= 8) {
1021 v->condover = decode012(gb);
1022 if (v->condover == CONDOVER_SELECT) {
1023 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1026 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1027 "Imode: %i, Invert: %i\n", status>>1, status&1);
1031 case AV_PICTURE_TYPE_P:
1032 if (v->field_mode) {
1033 v->numref = get_bits1(gb);
1035 v->reffield = get_bits1(gb);
1036 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1040 v->mvrange = get_unary(gb, 0, 3);
1044 if (v->extended_dmv)
1045 v->dmvrange = get_unary(gb, 0, 3);
1048 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1049 v->fourmvswitch = get_bits1(gb);
1050 v->intcomp = get_bits1(gb);
1052 v->lumscale = get_bits(gb, 6);
1053 v->lumshift = get_bits(gb, 6);
1054 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1055 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1058 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1059 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1060 "Imode: %i, Invert: %i\n", status>>1, status&1);
1061 mbmodetab = get_bits(gb, 2);
1062 if (v->fourmvswitch)
1063 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1065 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1066 imvtab = get_bits(gb, 2);
1067 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1068 // interlaced p-picture cbpcy range is [1, 63]
1069 icbptab = get_bits(gb, 3);
1070 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1071 twomvbptab = get_bits(gb, 2);
1072 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1073 if (v->fourmvswitch) {
1074 fourmvbptab = get_bits(gb, 2);
1075 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1079 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1080 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1081 v->range_x = 1 << (v->k_x - 1);
1082 v->range_y = 1 << (v->k_y - 1);
1086 else if (v->pq < 13)
1090 if (v->fcm != ILACE_FRAME) {
1092 mvmode = get_unary(gb, 1, 4);
1093 lowquant = (v->pq > 12) ? 0 : 1;
1094 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1095 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1097 mvmode2 = get_unary(gb, 1, 3);
1098 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1099 if (v->field_mode) {
1100 v->intcompfield = decode210(gb) ^ 3;
1102 v->intcompfield = 3;
1104 v->lumscale2 = v->lumscale = 32;
1105 v->lumshift2 = v->lumshift = 0;
1106 if (v->intcompfield & 1) {
1107 v->lumscale = get_bits(gb, 6);
1108 v->lumshift = get_bits(gb, 6);
1110 if ((v->intcompfield & 2) && v->field_mode) {
1111 v->lumscale2 = get_bits(gb, 6);
1112 v->lumshift2 = get_bits(gb, 6);
1113 } else if(!v->field_mode) {
1114 v->lumscale2 = v->lumscale;
1115 v->lumshift2 = v->lumshift;
1117 if (v->field_mode && v->second_field) {
1118 if (v->cur_field_type) {
1119 INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1120 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1122 INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1123 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1125 v->next_use_ic = *v->curr_use_ic = 1;
1127 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1128 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1132 v->qs_last = v->s.quarter_sample;
1133 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1134 v->s.quarter_sample = 0;
1135 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1136 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1137 v->s.quarter_sample = 0;
1139 v->s.quarter_sample = 1;
1141 v->s.quarter_sample = 1;
1142 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1143 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1144 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1146 if (v->fcm == PROGRESSIVE) { // progressive
1147 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1148 v->mv_mode2 == MV_PMODE_MIXED_MV)
1149 || v->mv_mode == MV_PMODE_MIXED_MV) {
1150 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1153 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1154 "Imode: %i, Invert: %i\n", status>>1, status&1);
1156 v->mv_type_is_raw = 0;
1157 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1159 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1162 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1163 "Imode: %i, Invert: %i\n", status>>1, status&1);
1165 /* Hopefully this is correct for P frames */
1166 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1167 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1168 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1169 v->qs_last = v->s.quarter_sample;
1170 v->s.quarter_sample = 1;
1172 } else { // field interlaced
1173 mbmodetab = get_bits(gb, 3);
1174 imvtab = get_bits(gb, 2 + v->numref);
1176 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1178 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1179 icbptab = get_bits(gb, 3);
1180 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1181 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1182 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1183 fourmvbptab = get_bits(gb, 2);
1184 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1185 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1187 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1191 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1192 vop_dquant_decoding(v);
1195 v->ttfrm = 0; //FIXME Is that so ?
1196 if (v->vstransform) {
1197 v->ttmbf = get_bits1(gb);
1199 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1206 case AV_PICTURE_TYPE_B:
1207 if (v->fcm == ILACE_FRAME) {
1208 if (read_bfraction(v, gb) < 0)
1209 return AVERROR_INVALIDDATA;
1210 if (v->bfraction == 0) {
1215 v->mvrange = get_unary(gb, 0, 3);
1218 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1219 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1220 v->range_x = 1 << (v->k_x - 1);
1221 v->range_y = 1 << (v->k_y - 1);
1225 else if (v->pq < 13)
1230 if (v->field_mode) {
1232 av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1233 if (v->extended_dmv)
1234 v->dmvrange = get_unary(gb, 0, 3);
1235 mvmode = get_unary(gb, 1, 3);
1236 lowquant = (v->pq > 12) ? 0 : 1;
1237 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1238 v->qs_last = v->s.quarter_sample;
1239 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1240 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1241 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1244 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1245 "Imode: %i, Invert: %i\n", status>>1, status&1);
1246 mbmodetab = get_bits(gb, 3);
1247 if (v->mv_mode == MV_PMODE_MIXED_MV)
1248 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1250 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1251 imvtab = get_bits(gb, 3);
1252 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1253 icbptab = get_bits(gb, 3);
1254 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1255 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1256 fourmvbptab = get_bits(gb, 2);
1257 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1259 v->numref = 1; // interlaced field B pictures are always 2-ref
1260 } else if (v->fcm == ILACE_FRAME) {
1261 if (v->extended_dmv)
1262 v->dmvrange = get_unary(gb, 0, 3);
1263 if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1264 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1266 v->mv_mode = MV_PMODE_1MV;
1267 v->fourmvswitch = 0;
1268 v->qs_last = v->s.quarter_sample;
1269 v->s.quarter_sample = 1;
1271 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1274 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1275 "Imode: %i, Invert: %i\n", status>>1, status&1);
1276 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1279 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1280 "Imode: %i, Invert: %i\n", status>>1, status&1);
1281 mbmodetab = get_bits(gb, 2);
1282 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1283 imvtab = get_bits(gb, 2);
1284 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1285 // interlaced p/b-picture cbpcy range is [1, 63]
1286 icbptab = get_bits(gb, 3);
1287 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1288 twomvbptab = get_bits(gb, 2);
1289 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1290 fourmvbptab = get_bits(gb, 2);
1291 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1293 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1294 v->qs_last = v->s.quarter_sample;
1295 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1296 v->s.mspel = v->s.quarter_sample;
1297 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1300 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1301 "Imode: %i, Invert: %i\n", status>>1, status&1);
1302 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1305 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1306 "Imode: %i, Invert: %i\n", status>>1, status&1);
1307 v->s.mv_table_index = get_bits(gb, 2);
1308 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1312 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1313 vop_dquant_decoding(v);
1317 if (v->vstransform) {
1318 v->ttmbf = get_bits1(gb);
1320 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1329 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1335 v->c_ac_table_index = decode012(gb);
1336 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1337 v->y_ac_table_index = decode012(gb);
1340 v->s.dc_table_index = get_bits1(gb);
1341 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1343 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1344 vop_dquant_decoding(v);
1348 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1349 v->s.pict_type = AV_PICTURE_TYPE_B;
1355 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1357 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1358 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1359 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1360 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1361 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1362 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1363 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1364 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1365 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1366 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1367 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1368 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1369 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1370 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1371 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1372 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1373 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1374 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1375 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1376 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1377 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1378 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1379 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1380 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1381 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1382 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1383 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1384 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1385 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1386 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1387 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1390 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1391 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1392 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1393 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1394 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1395 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1396 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1397 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1398 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1399 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1400 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1401 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1402 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1403 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1404 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1405 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1406 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1407 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1408 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1409 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1410 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1411 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1412 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1413 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1414 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1415 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1416 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1417 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1421 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1422 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1423 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1424 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1425 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1426 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1427 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1428 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1429 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1430 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1431 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1432 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1433 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1434 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1435 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1436 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1437 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1438 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1439 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1440 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1441 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1442 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1446 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1447 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1448 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1449 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1450 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1451 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1452 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1453 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1454 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1455 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1456 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1457 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1458 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1459 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1460 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1461 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1462 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1463 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1464 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1465 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1466 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1467 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1468 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1469 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1470 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1473 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1474 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1475 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1476 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1477 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1478 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1479 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1480 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1481 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1482 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1483 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1484 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1485 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1486 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1487 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1488 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1489 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1493 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1494 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1495 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1496 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1497 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1498 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1499 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1500 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1501 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1502 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1503 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1504 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1505 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1506 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1507 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1508 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1509 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1513 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1514 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1515 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1516 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1517 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1518 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1519 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1520 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1521 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1522 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1523 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1524 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1525 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1526 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1527 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1528 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1529 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1530 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1531 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1532 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1533 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1534 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1535 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1536 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1537 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1538 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1539 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1543 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1544 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1545 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1546 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1547 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1548 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1549 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1550 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1551 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1552 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1553 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1554 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1555 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1556 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1557 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1558 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1559 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1560 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1561 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1562 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1563 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1564 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1565 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1566 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1567 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1568 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1569 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1570 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1571 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1576 static const uint16_t vlc_offs[] = {
1577 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1578 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1579 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1580 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1581 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1582 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1583 31714, 31746, 31778, 32306, 32340, 32372
1587 * Init VC-1 specific tables and VC1Context members
1588 * @param v The VC1Context to initialize
1591 av_cold int ff_vc1_init_common(VC1Context *v)
1593 static int done = 0;
1595 static VLC_TYPE vlc_table[32372][2];
1597 v->hrd_rate = v->hrd_buffer = NULL;
1601 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1602 ff_vc1_bfraction_bits, 1, 1,
1603 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1604 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1605 ff_vc1_norm2_bits, 1, 1,
1606 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1607 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1608 ff_vc1_norm6_bits, 1, 1,
1609 ff_vc1_norm6_codes, 2, 2, 556);
1610 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1611 ff_vc1_imode_bits, 1, 1,
1612 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1613 for (i = 0; i < 3; i++) {
1614 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1615 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1616 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1617 ff_vc1_ttmb_bits[i], 1, 1,
1618 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1619 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1620 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1621 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1622 ff_vc1_ttblk_bits[i], 1, 1,
1623 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1624 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1625 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1626 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1627 ff_vc1_subblkpat_bits[i], 1, 1,
1628 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1630 for (i = 0; i < 4; i++) {
1631 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1632 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1633 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1634 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1635 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1636 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1637 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1638 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1639 ff_vc1_cbpcy_p_bits[i], 1, 1,
1640 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1641 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1642 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1643 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1644 ff_vc1_mv_diff_bits[i], 1, 1,
1645 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1647 for (i = 0; i < 8; i++) {
1648 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1649 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1650 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1651 &vc1_ac_tables[i][0][1], 8, 4,
1652 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1653 /* initialize interlaced MVDATA tables (2-Ref) */
1654 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1655 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1656 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1657 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1658 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1660 for (i = 0; i < 4; i++) {
1661 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1662 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1663 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1664 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1665 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1666 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1667 /* initialize NON-4MV MBMODE VLC tables for the same */
1668 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1669 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1670 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1671 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1672 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1673 /* initialize interlaced MVDATA tables (1-Ref) */
1674 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1675 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1676 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1677 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1678 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1680 for (i = 0; i < 4; i++) {
1681 /* Initialize 2MV Block pattern VLC tables */
1682 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1683 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1684 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1685 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1686 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1688 for (i = 0; i < 8; i++) {
1689 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1690 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1691 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1692 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1693 ff_vc1_icbpcy_p_bits[i], 1, 1,
1694 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1695 /* Initialize interlaced field picture MBMODE VLC tables */
1696 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1697 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1698 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1699 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1700 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1701 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1702 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1703 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1704 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1705 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1710 /* Other defaults */
1712 v->mvrange = 0; /* 7.1.1.18, p80 */
1714 ff_vc1dsp_init(&v->vc1dsp);