2 * VC-1 and WMV3 decoder common code
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of Libav.
9 * Libav is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * Libav is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with Libav; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder common code
29 #include "libavutil/attributes.h"
32 #include "mpegvideo.h"
37 #include "simple_idct.h"
39 /***********************************************************************/
41 * @name VC-1 Bitplane decoding
59 /** @} */ //imode defines
61 /** Decode rows by checking if they are skipped
62 * @param plane Buffer to store decoded bits
63 * @param[in] width Width of this buffer
64 * @param[in] height Height of this buffer
65 * @param[in] stride of this buffer
67 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
72 for (y = 0; y < height; y++) {
73 if (!get_bits1(gb)) //rowskip
74 memset(plane, 0, width);
76 for (x = 0; x < width; x++)
77 plane[x] = get_bits1(gb);
82 /** Decode columns by checking if they are skipped
83 * @param plane Buffer to store decoded bits
84 * @param[in] width Width of this buffer
85 * @param[in] height Height of this buffer
86 * @param[in] stride of this buffer
87 * @todo FIXME: Optimize
89 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
94 for (x = 0; x < width; x++) {
95 if (!get_bits1(gb)) //colskip
96 for (y = 0; y < height; y++)
99 for (y = 0; y < height; y++)
100 plane[y*stride] = get_bits1(gb);
105 /** Decode a bitplane's bits
106 * @param data bitplane where to store the decode bits
107 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
108 * @param v VC-1 context for bit reading and logging
110 * @todo FIXME: Optimize
112 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
114 GetBitContext *gb = &v->s.gb;
116 int imode, x, y, code, offset;
117 uint8_t invert, *planep = data;
118 int width, height, stride;
120 width = v->s.mb_width;
121 height = v->s.mb_height >> v->field_mode;
122 stride = v->s.mb_stride;
123 invert = get_bits1(gb);
124 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
129 //Data is actually read in the MB layer (same for all tests == "raw")
130 *raw_flag = 1; //invert ignored
134 if ((height * width) & 1) {
135 *planep++ = get_bits1(gb);
140 // decode bitplane as one long line
141 for (y = offset; y < height * width; y += 2) {
142 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
143 *planep++ = code & 1;
145 if (offset == width) {
147 planep += stride - width;
149 *planep++ = code >> 1;
151 if (offset == width) {
153 planep += stride - width;
159 if (!(height % 3) && (width % 3)) { // use 2x3 decoding
160 for (y = 0; y < height; y += 3) {
161 for (x = width & 1; x < width; x += 2) {
162 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
164 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
167 planep[x + 0] = (code >> 0) & 1;
168 planep[x + 1] = (code >> 1) & 1;
169 planep[x + 0 + stride] = (code >> 2) & 1;
170 planep[x + 1 + stride] = (code >> 3) & 1;
171 planep[x + 0 + stride * 2] = (code >> 4) & 1;
172 planep[x + 1 + stride * 2] = (code >> 5) & 1;
174 planep += stride * 3;
177 decode_colskip(data, 1, height, stride, &v->s.gb);
179 planep += (height & 1) * stride;
180 for (y = height & 1; y < height; y += 2) {
181 for (x = width % 3; x < width; x += 3) {
182 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
184 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
187 planep[x + 0] = (code >> 0) & 1;
188 planep[x + 1] = (code >> 1) & 1;
189 planep[x + 2] = (code >> 2) & 1;
190 planep[x + 0 + stride] = (code >> 3) & 1;
191 planep[x + 1 + stride] = (code >> 4) & 1;
192 planep[x + 2 + stride] = (code >> 5) & 1;
194 planep += stride * 2;
198 decode_colskip(data, x, height, stride, &v->s.gb);
200 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
204 decode_rowskip(data, width, height, stride, &v->s.gb);
207 decode_colskip(data, width, height, stride, &v->s.gb);
213 /* Applying diff operator */
214 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
217 for (x = 1; x < width; x++)
218 planep[x] ^= planep[x-1];
219 for (y = 1; y < height; y++) {
221 planep[0] ^= planep[-stride];
222 for (x = 1; x < width; x++) {
223 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
224 else planep[x] ^= planep[x-1];
229 for (x = 0; x < stride * height; x++)
230 planep[x] = !planep[x]; //FIXME stride
232 return (imode << 1) + invert;
235 /** @} */ //Bitplane group
237 /***********************************************************************/
238 /** VOP Dquant decoding
239 * @param v VC-1 Context
241 static int vop_dquant_decoding(VC1Context *v)
243 GetBitContext *gb = &v->s.gb;
247 if (v->dquant == 2) {
248 pqdiff = get_bits(gb, 3);
250 v->altpq = get_bits(gb, 5);
252 v->altpq = v->pq + pqdiff + 1;
254 v->dquantfrm = get_bits1(gb);
256 v->dqprofile = get_bits(gb, 2);
257 switch (v->dqprofile) {
258 case DQPROFILE_SINGLE_EDGE:
259 case DQPROFILE_DOUBLE_EDGES:
260 v->dqsbedge = get_bits(gb, 2);
262 case DQPROFILE_ALL_MBS:
263 v->dqbilevel = get_bits1(gb);
269 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
270 pqdiff = get_bits(gb, 3);
272 v->altpq = get_bits(gb, 5);
274 v->altpq = v->pq + pqdiff + 1;
281 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
284 * Decode Simple/Main Profiles sequence header
285 * @see Figure 7-8, p16-17
286 * @param avctx Codec context
287 * @param gb GetBit context initialized from Codec context extra_data
290 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
292 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
293 v->profile = get_bits(gb, 2);
294 if (v->profile == PROFILE_COMPLEX) {
295 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
298 if (v->profile == PROFILE_ADVANCED) {
299 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
300 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
301 return decode_sequence_header_adv(v, gb);
303 v->zz_8x4 = ff_wmv2_scantableA;
304 v->zz_4x8 = ff_wmv2_scantableB;
305 v->res_y411 = get_bits1(gb);
306 v->res_sprite = get_bits1(gb);
308 av_log(avctx, AV_LOG_ERROR,
309 "Old interlaced mode is not supported\n");
315 v->frmrtq_postproc = get_bits(gb, 3); //common
316 // (bitrate-32kbps)/64kbps
317 v->bitrtq_postproc = get_bits(gb, 5); //common
318 v->s.loop_filter = get_bits1(gb); //common
319 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
320 av_log(avctx, AV_LOG_ERROR,
321 "LOOPFILTER shall not be enabled in Simple Profile\n");
323 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
324 v->s.loop_filter = 0;
326 v->res_x8 = get_bits1(gb); //reserved
327 v->multires = get_bits1(gb);
328 v->res_fasttx = get_bits1(gb);
329 if (!v->res_fasttx) {
330 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;
331 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
332 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
333 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
334 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
335 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
336 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
337 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
340 v->fastuvmc = get_bits1(gb); //common
341 if (!v->profile && !v->fastuvmc) {
342 av_log(avctx, AV_LOG_ERROR,
343 "FASTUVMC unavailable in Simple Profile\n");
346 v->extended_mv = get_bits1(gb); //common
347 if (!v->profile && v->extended_mv)
349 av_log(avctx, AV_LOG_ERROR,
350 "Extended MVs unavailable in Simple Profile\n");
353 v->dquant = get_bits(gb, 2); //common
354 v->vstransform = get_bits1(gb); //common
356 v->res_transtab = get_bits1(gb);
359 av_log(avctx, AV_LOG_ERROR,
360 "1 for reserved RES_TRANSTAB is forbidden\n");
364 v->overlap = get_bits1(gb); //common
366 v->resync_marker = get_bits1(gb);
367 v->rangered = get_bits1(gb);
368 if (v->rangered && v->profile == PROFILE_SIMPLE) {
369 av_log(avctx, AV_LOG_INFO,
370 "RANGERED should be set to 0 in Simple Profile\n");
373 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
374 v->quantizer_mode = get_bits(gb, 2); //common
376 v->finterpflag = get_bits1(gb); //common
379 v->s.avctx->width = v->s.avctx->coded_width = get_bits(gb, 11);
380 v->s.avctx->height = v->s.avctx->coded_height = get_bits(gb, 11);
381 skip_bits(gb, 5); //frame rate
382 v->res_x8 = get_bits1(gb);
383 if (get_bits1(gb)) { // something to do with DC VLC selection
384 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
387 skip_bits(gb, 3); //slice code
390 v->res_rtm_flag = get_bits1(gb); //reserved
392 if (!v->res_rtm_flag) {
393 av_log(avctx, AV_LOG_ERROR,
394 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
397 //TODO: figure out what they mean (always 0x402F)
400 av_log(avctx, AV_LOG_DEBUG,
401 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
402 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
403 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
404 "DQuant=%i, Quantizer mode=%i, Max B-frames=%i\n",
405 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
406 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
407 v->rangered, v->vstransform, v->overlap, v->resync_marker,
408 v->dquant, v->quantizer_mode, avctx->max_b_frames);
412 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
415 v->level = get_bits(gb, 3);
417 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
419 v->chromaformat = get_bits(gb, 2);
420 if (v->chromaformat != 1) {
421 av_log(v->s.avctx, AV_LOG_ERROR,
422 "Only 4:2:0 chroma format supported\n");
427 v->frmrtq_postproc = get_bits(gb, 3); //common
428 // (bitrate-32kbps)/64kbps
429 v->bitrtq_postproc = get_bits(gb, 5); //common
430 v->postprocflag = get_bits1(gb); //common
432 v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
433 v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
434 v->s.avctx->width = v->s.avctx->coded_width;
435 v->s.avctx->height = v->s.avctx->coded_height;
436 v->broadcast = get_bits1(gb);
437 v->interlace = get_bits1(gb);
438 v->tfcntrflag = get_bits1(gb);
439 v->finterpflag = get_bits1(gb);
440 skip_bits1(gb); // reserved
442 av_log(v->s.avctx, AV_LOG_DEBUG,
443 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
444 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
445 "TFCTRflag=%i, FINTERPflag=%i\n",
446 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
447 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
448 v->tfcntrflag, v->finterpflag);
450 v->psf = get_bits1(gb);
451 if (v->psf) { //PsF, 6.1.13
452 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
455 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
456 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
458 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
459 w = get_bits(gb, 14) + 1;
460 h = get_bits(gb, 14) + 1;
461 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
463 ar = get_bits(gb, 4);
465 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
466 } else if (ar == 15) {
467 w = get_bits(gb, 8) + 1;
468 h = get_bits(gb, 8) + 1;
469 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
471 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
472 &v->s.avctx->sample_aspect_ratio.den,
473 v->s.avctx->height * w,
474 v->s.avctx->width * h,
477 ff_set_sar(v->s.avctx, v->s.avctx->sample_aspect_ratio);
478 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
479 v->s.avctx->sample_aspect_ratio.num,
480 v->s.avctx->sample_aspect_ratio.den);
482 if (get_bits1(gb)) { //framerate stuff
484 v->s.avctx->framerate.den = 32;
485 v->s.avctx->framerate.num = get_bits(gb, 16) + 1;
488 nr = get_bits(gb, 8);
489 dr = get_bits(gb, 4);
490 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
491 v->s.avctx->framerate.den = ff_vc1_fps_dr[dr - 1];
492 v->s.avctx->framerate.num = ff_vc1_fps_nr[nr - 1] * 1000;
495 if (v->broadcast) { // Pulldown may be present
496 v->s.avctx->framerate.num *= 2;
497 v->s.avctx->ticks_per_frame = 2;
502 v->color_prim = get_bits(gb, 8);
503 v->transfer_char = get_bits(gb, 8);
504 v->matrix_coef = get_bits(gb, 8);
508 v->hrd_param_flag = get_bits1(gb);
509 if (v->hrd_param_flag) {
511 v->hrd_num_leaky_buckets = get_bits(gb, 5);
512 skip_bits(gb, 4); //bitrate exponent
513 skip_bits(gb, 4); //buffer size exponent
514 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
515 skip_bits(gb, 16); //hrd_rate[n]
516 skip_bits(gb, 16); //hrd_buffer[n]
522 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
526 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
527 v->broken_link = get_bits1(gb);
528 v->closed_entry = get_bits1(gb);
529 v->panscanflag = get_bits1(gb);
530 v->refdist_flag = get_bits1(gb);
531 v->s.loop_filter = get_bits1(gb);
532 v->fastuvmc = get_bits1(gb);
533 v->extended_mv = get_bits1(gb);
534 v->dquant = get_bits(gb, 2);
535 v->vstransform = get_bits1(gb);
536 v->overlap = get_bits1(gb);
537 v->quantizer_mode = get_bits(gb, 2);
539 if (v->hrd_param_flag) {
540 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
541 skip_bits(gb, 8); //hrd_full[n]
546 avctx->width = avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
547 avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
550 v->extended_dmv = get_bits1(gb);
551 if ((v->range_mapy_flag = get_bits1(gb))) {
552 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
553 v->range_mapy = get_bits(gb, 3);
555 if ((v->range_mapuv_flag = get_bits1(gb))) {
556 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
557 v->range_mapuv = get_bits(gb, 3);
560 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
561 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
562 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
563 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
564 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
565 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
570 /* fill lookup tables for intensity compensation */
571 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \
572 int scale, shift, i; \
575 shift = (255 - lumshift * 2) << 6; \
579 scale = lumscale + 32; \
581 shift = (lumshift - 64) << 6; \
583 shift = lumshift << 6; \
585 for (i = 0; i < 256; i++) { \
586 int iy = chain ? luty[i] : i; \
587 int iu = chain ? lutuv[i] : i; \
588 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
589 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
593 static void rotate_luts(VC1Context *v)
595 #define ROTATE(DEF, L, N, C, A) do { \
596 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
600 memcpy(&tmp, &L , sizeof(tmp)); \
601 memcpy(&L , &N , sizeof(tmp)); \
602 memcpy(&N , &tmp, sizeof(tmp)); \
607 ROTATE(int tmp, v->last_use_ic, v->next_use_ic, v->curr_use_ic, v->aux_use_ic);
608 ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
609 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
611 INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
612 INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
614 if (v->curr_luty == v->next_luty) {
615 // If we just initialized next_lut, clear next_use_ic to match.
620 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
622 int pqindex, lowquant, status;
625 v->interpfrm = get_bits1(gb);
626 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
629 v->multires = get_bits(gb, 2) == 1;
631 skip_bits(gb, 2); //framecnt unused
634 v->rangeredfrm = get_bits1(gb);
635 v->s.pict_type = get_bits1(gb);
636 if (v->s.avctx->max_b_frames) {
637 if (!v->s.pict_type) {
639 v->s.pict_type = AV_PICTURE_TYPE_I;
641 v->s.pict_type = AV_PICTURE_TYPE_B;
643 v->s.pict_type = AV_PICTURE_TYPE_P;
645 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
648 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
649 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
650 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
651 if (v->bfraction == 0) {
652 v->s.pict_type = AV_PICTURE_TYPE_BI;
655 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
656 skip_bits(gb, 7); // skip buffer fullness
662 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
664 if (v->s.pict_type == AV_PICTURE_TYPE_P)
667 /* Quantizer stuff */
668 pqindex = get_bits(gb, 5);
671 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
672 v->pq = ff_vc1_pquant_table[0][pqindex];
674 v->pq = ff_vc1_pquant_table[1][pqindex];
677 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
678 v->pquantizer = pqindex < 9;
679 if (v->quantizer_mode == QUANT_NON_UNIFORM)
681 v->pqindex = pqindex;
683 v->halfpq = get_bits1(gb);
686 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
687 v->pquantizer = get_bits1(gb);
689 if (v->extended_mv == 1)
690 v->mvrange = get_unary(gb, 0, 3);
691 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
692 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
693 v->range_x = 1 << (v->k_x - 1);
694 v->range_y = 1 << (v->k_y - 1);
695 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
696 v->respic = get_bits(gb, 2);
698 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
699 v->x8_type = get_bits1(gb);
702 ff_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
703 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
704 pqindex, v->pq, v->halfpq, v->rangeredfrm);
706 if (v->first_pic_header_flag)
709 switch (v->s.pict_type) {
710 case AV_PICTURE_TYPE_P:
711 if (v->pq < 5) v->tt_index = 0;
712 else if (v->pq < 13) v->tt_index = 1;
713 else v->tt_index = 2;
715 lowquant = (v->pq > 12) ? 0 : 1;
716 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
717 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
718 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
719 v->lumscale = get_bits(gb, 6);
720 v->lumshift = get_bits(gb, 6);
722 /* fill lookup tables for intensity compensation */
723 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
724 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
726 v->qs_last = v->s.quarter_sample;
727 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
728 v->s.quarter_sample = 0;
729 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
730 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
731 v->s.quarter_sample = 0;
733 v->s.quarter_sample = 1;
735 v->s.quarter_sample = 1;
736 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));
738 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
739 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
740 v->mv_mode == MV_PMODE_MIXED_MV) {
741 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
744 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
745 "Imode: %i, Invert: %i\n", status>>1, status&1);
747 v->mv_type_is_raw = 0;
748 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
750 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
753 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
754 "Imode: %i, Invert: %i\n", status>>1, status&1);
756 /* Hopefully this is correct for P-frames */
757 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
758 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
761 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
762 vop_dquant_decoding(v);
765 v->ttfrm = 0; //FIXME Is that so ?
766 if (v->vstransform) {
767 v->ttmbf = get_bits1(gb);
769 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
776 case AV_PICTURE_TYPE_B:
777 if (v->pq < 5) v->tt_index = 0;
778 else if (v->pq < 13) v->tt_index = 1;
779 else v->tt_index = 2;
781 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
782 v->qs_last = v->s.quarter_sample;
783 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
784 v->s.mspel = v->s.quarter_sample;
786 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
789 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
790 "Imode: %i, Invert: %i\n", status>>1, status&1);
791 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
794 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
795 "Imode: %i, Invert: %i\n", status>>1, status&1);
797 v->s.mv_table_index = get_bits(gb, 2);
798 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
801 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
802 vop_dquant_decoding(v);
806 if (v->vstransform) {
807 v->ttmbf = get_bits1(gb);
809 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
820 v->c_ac_table_index = decode012(gb);
821 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
822 v->y_ac_table_index = decode012(gb);
825 v->s.dc_table_index = get_bits1(gb);
828 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
829 v->s.pict_type = AV_PICTURE_TYPE_B;
835 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
837 int pqindex, lowquant;
839 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
843 v->p_frame_skipped = 0;
844 if (v->second_field) {
845 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
847 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
848 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
849 if (!v->pic_header_flag)
850 goto parse_common_info;
857 if (fcm == ILACE_FIELD)
863 if (!v->first_pic_header_flag && v->field_mode != field_mode)
864 return AVERROR_INVALIDDATA;
865 v->field_mode = field_mode;
869 v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
870 v->fptype = get_bits(gb, 3);
871 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
872 if (v->fptype & 4) // B-picture
873 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
875 v->s.mb_height = v->s.height + 15 >> 4;
876 switch (get_unary(gb, 0, 4)) {
878 v->s.pict_type = AV_PICTURE_TYPE_P;
881 v->s.pict_type = AV_PICTURE_TYPE_B;
884 v->s.pict_type = AV_PICTURE_TYPE_I;
887 v->s.pict_type = AV_PICTURE_TYPE_BI;
890 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
891 v->p_frame_skipped = 1;
898 if (!v->interlace || v->psf) {
899 v->rptfrm = get_bits(gb, 2);
901 v->tff = get_bits1(gb);
902 v->rff = get_bits1(gb);
905 if (v->panscanflag) {
906 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
909 if (v->p_frame_skipped) {
912 v->rnd = get_bits1(gb);
914 v->uvsamp = get_bits1(gb);
916 if (!v->refdist_flag)
918 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
919 v->refdist = get_bits(gb, 2);
921 v->refdist += get_unary(gb, 0, 16);
923 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
924 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
925 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
926 v->frfd = (v->bfraction * v->refdist) >> 8;
927 v->brfd = v->refdist - v->frfd - 1;
931 goto parse_common_info;
933 if (v->fcm == PROGRESSIVE) {
935 v->interpfrm = get_bits1(gb);
936 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
937 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
938 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
939 if (v->bfraction == 0) {
940 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
947 v->cur_field_type = !(v->tff ^ v->second_field);
948 pqindex = get_bits(gb, 5);
951 v->pqindex = pqindex;
952 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
953 v->pq = ff_vc1_pquant_table[0][pqindex];
955 v->pq = ff_vc1_pquant_table[1][pqindex];
958 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
959 v->pquantizer = pqindex < 9;
960 if (v->quantizer_mode == QUANT_NON_UNIFORM)
962 v->pqindex = pqindex;
964 v->halfpq = get_bits1(gb);
967 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
968 v->pquantizer = get_bits1(gb);
970 v->postproc = get_bits(gb, 2);
975 if (v->first_pic_header_flag)
978 switch (v->s.pict_type) {
979 case AV_PICTURE_TYPE_I:
980 case AV_PICTURE_TYPE_BI:
981 if (v->fcm == ILACE_FRAME) { //interlace frame picture
982 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
985 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
986 "Imode: %i, Invert: %i\n", status>>1, status&1);
988 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
991 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
992 "Imode: %i, Invert: %i\n", status>>1, status&1);
993 v->condover = CONDOVER_NONE;
994 if (v->overlap && v->pq <= 8) {
995 v->condover = decode012(gb);
996 if (v->condover == CONDOVER_SELECT) {
997 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1000 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1001 "Imode: %i, Invert: %i\n", status>>1, status&1);
1005 case AV_PICTURE_TYPE_P:
1006 if (v->field_mode) {
1007 v->numref = get_bits1(gb);
1009 v->reffield = get_bits1(gb);
1010 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1014 v->mvrange = get_unary(gb, 0, 3);
1018 if (v->extended_dmv)
1019 v->dmvrange = get_unary(gb, 0, 3);
1022 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1023 v->fourmvswitch = get_bits1(gb);
1024 v->intcomp = get_bits1(gb);
1026 v->lumscale = get_bits(gb, 6);
1027 v->lumshift = get_bits(gb, 6);
1028 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1029 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1032 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1033 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1034 "Imode: %i, Invert: %i\n", status>>1, status&1);
1035 mbmodetab = get_bits(gb, 2);
1036 if (v->fourmvswitch)
1037 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1039 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1040 imvtab = get_bits(gb, 2);
1041 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1042 // interlaced p-picture cbpcy range is [1, 63]
1043 icbptab = get_bits(gb, 3);
1044 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1045 twomvbptab = get_bits(gb, 2);
1046 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1047 if (v->fourmvswitch) {
1048 fourmvbptab = get_bits(gb, 2);
1049 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1053 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1054 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1055 v->range_x = 1 << (v->k_x - 1);
1056 v->range_y = 1 << (v->k_y - 1);
1060 else if (v->pq < 13)
1064 if (v->fcm != ILACE_FRAME) {
1066 mvmode = get_unary(gb, 1, 4);
1067 lowquant = (v->pq > 12) ? 0 : 1;
1068 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1069 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1071 mvmode2 = get_unary(gb, 1, 3);
1072 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1073 if (v->field_mode) {
1074 v->intcompfield = decode210(gb) ^ 3;
1076 v->intcompfield = 3;
1078 v->lumscale2 = v->lumscale = 32;
1079 v->lumshift2 = v->lumshift = 0;
1080 if (v->intcompfield & 1) {
1081 v->lumscale = get_bits(gb, 6);
1082 v->lumshift = get_bits(gb, 6);
1084 if ((v->intcompfield & 2) && v->field_mode) {
1085 v->lumscale2 = get_bits(gb, 6);
1086 v->lumshift2 = get_bits(gb, 6);
1087 } else if(!v->field_mode) {
1088 v->lumscale2 = v->lumscale;
1089 v->lumshift2 = v->lumshift;
1091 if (v->field_mode && v->second_field) {
1092 if (v->cur_field_type) {
1093 INIT_LUT(v->lumscale , v->lumshift , v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1094 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1096 INIT_LUT(v->lumscale2, v->lumshift2, v->curr_luty[v->cur_field_type^1], v->curr_lutuv[v->cur_field_type^1], 0);
1097 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[v->cur_field_type ], v->last_lutuv[v->cur_field_type ], 1);
1099 v->next_use_ic = v->curr_use_ic = 1;
1101 INIT_LUT(v->lumscale , v->lumshift , v->last_luty[0], v->last_lutuv[0], 1);
1102 INIT_LUT(v->lumscale2, v->lumshift2, v->last_luty[1], v->last_lutuv[1], 1);
1106 v->qs_last = v->s.quarter_sample;
1107 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1108 v->s.quarter_sample = 0;
1109 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1110 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1111 v->s.quarter_sample = 0;
1113 v->s.quarter_sample = 1;
1115 v->s.quarter_sample = 1;
1116 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1117 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
1118 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1120 if (v->fcm == PROGRESSIVE) { // progressive
1121 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1122 v->mv_mode2 == MV_PMODE_MIXED_MV)
1123 || v->mv_mode == MV_PMODE_MIXED_MV) {
1124 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1127 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1128 "Imode: %i, Invert: %i\n", status>>1, status&1);
1130 v->mv_type_is_raw = 0;
1131 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1133 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1136 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1137 "Imode: %i, Invert: %i\n", status>>1, status&1);
1139 /* Hopefully this is correct for P-frames */
1140 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1141 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1142 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1143 v->qs_last = v->s.quarter_sample;
1144 v->s.quarter_sample = 1;
1146 } else { // field interlaced
1147 mbmodetab = get_bits(gb, 3);
1148 imvtab = get_bits(gb, 2 + v->numref);
1150 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1152 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1153 icbptab = get_bits(gb, 3);
1154 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1155 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1156 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1157 fourmvbptab = get_bits(gb, 2);
1158 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1159 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1161 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1165 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1166 vop_dquant_decoding(v);
1169 v->ttfrm = 0; //FIXME Is that so ?
1170 if (v->vstransform) {
1171 v->ttmbf = get_bits1(gb);
1173 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1180 case AV_PICTURE_TYPE_B:
1181 if (v->fcm == ILACE_FRAME) {
1182 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1183 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
1184 if (v->bfraction == 0) {
1189 v->mvrange = get_unary(gb, 0, 3);
1192 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1193 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1194 v->range_x = 1 << (v->k_x - 1);
1195 v->range_y = 1 << (v->k_y - 1);
1199 else if (v->pq < 13)
1204 if (v->field_mode) {
1206 if (v->extended_dmv)
1207 v->dmvrange = get_unary(gb, 0, 3);
1208 mvmode = get_unary(gb, 1, 3);
1209 lowquant = (v->pq > 12) ? 0 : 1;
1210 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1211 v->qs_last = v->s.quarter_sample;
1212 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1213 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
1214 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1217 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1218 "Imode: %i, Invert: %i\n", status>>1, status&1);
1219 mbmodetab = get_bits(gb, 3);
1220 if (v->mv_mode == MV_PMODE_MIXED_MV)
1221 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1223 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1224 imvtab = get_bits(gb, 3);
1225 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1226 icbptab = get_bits(gb, 3);
1227 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1228 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1229 fourmvbptab = get_bits(gb, 2);
1230 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1232 v->numref = 1; // interlaced field B pictures are always 2-ref
1233 } else if (v->fcm == ILACE_FRAME) {
1234 if (v->extended_dmv)
1235 v->dmvrange = get_unary(gb, 0, 3);
1236 if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1237 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1239 v->mv_mode = MV_PMODE_1MV;
1240 v->fourmvswitch = 0;
1241 v->qs_last = v->s.quarter_sample;
1242 v->s.quarter_sample = 1;
1244 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1247 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1248 "Imode: %i, Invert: %i\n", status>>1, status&1);
1249 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1252 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1253 "Imode: %i, Invert: %i\n", status>>1, status&1);
1254 mbmodetab = get_bits(gb, 2);
1255 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1256 imvtab = get_bits(gb, 2);
1257 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1258 // interlaced p/b-picture cbpcy range is [1, 63]
1259 icbptab = get_bits(gb, 3);
1260 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1261 twomvbptab = get_bits(gb, 2);
1262 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1263 fourmvbptab = get_bits(gb, 2);
1264 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1266 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1267 v->qs_last = v->s.quarter_sample;
1268 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1269 v->s.mspel = v->s.quarter_sample;
1270 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1273 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1274 "Imode: %i, Invert: %i\n", status>>1, status&1);
1275 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1278 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1279 "Imode: %i, Invert: %i\n", status>>1, status&1);
1280 v->s.mv_table_index = get_bits(gb, 2);
1281 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1285 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1286 vop_dquant_decoding(v);
1290 if (v->vstransform) {
1291 v->ttmbf = get_bits1(gb);
1293 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1302 if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1308 v->c_ac_table_index = decode012(gb);
1309 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1310 v->y_ac_table_index = decode012(gb);
1313 v->s.dc_table_index = get_bits1(gb);
1314 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1316 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1317 vop_dquant_decoding(v);
1321 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1322 v->s.pict_type = AV_PICTURE_TYPE_B;
1328 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1330 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1331 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1332 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1333 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1334 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1335 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1336 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1337 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1338 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1339 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1340 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1341 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1342 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1343 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1344 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1345 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1346 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1347 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1348 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1349 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1350 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1351 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1352 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1353 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1354 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1355 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1356 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1357 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1358 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1359 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1360 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1363 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1364 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1365 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1366 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1367 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1368 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1369 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1370 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1371 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1372 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1373 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1374 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1375 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1376 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1377 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1378 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1379 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1380 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1381 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1382 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1383 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1384 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1385 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1386 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1387 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1388 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1389 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1390 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1394 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1395 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1396 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1397 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1398 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1399 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1400 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1401 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1402 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1403 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1404 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1405 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1406 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1407 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1408 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1409 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1410 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1411 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1412 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1413 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1414 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1415 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1419 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1420 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1421 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1422 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1423 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1424 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1425 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1426 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1427 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1428 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1429 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1430 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1431 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1432 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1433 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1434 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1435 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1436 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1437 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1438 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1439 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1440 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1441 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1442 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1443 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1446 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1447 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1448 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1449 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1450 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1451 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1452 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1453 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1454 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1455 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1456 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1457 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1458 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1459 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1460 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1461 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1462 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1466 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1467 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1468 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1469 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1470 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1471 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1472 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1473 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1474 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1475 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1476 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1477 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1478 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1479 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1480 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1481 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1482 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1486 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1487 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1488 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1489 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1490 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1491 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1492 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1493 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1494 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1495 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1496 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1497 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1498 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1499 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1500 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1501 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1502 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1503 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1504 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1505 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1506 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1507 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1508 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1509 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1510 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1511 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1512 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1516 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1517 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1518 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1519 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1520 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1521 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1522 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1523 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1524 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1525 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1526 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1527 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1528 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1529 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1530 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1531 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1532 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1533 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1534 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1535 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1536 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1537 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1538 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1539 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1540 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1541 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1542 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1543 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1544 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1549 static const uint16_t vlc_offs[] = {
1550 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1551 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1552 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1553 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1554 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1555 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1556 31714, 31746, 31778, 32306, 32340, 32372
1560 * Init VC-1 specific tables and VC1Context members
1561 * @param v The VC1Context to initialize
1564 av_cold int ff_vc1_init_common(VC1Context *v)
1566 static int done = 0;
1568 static VLC_TYPE vlc_table[32372][2];
1570 v->hrd_rate = v->hrd_buffer = NULL;
1574 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1575 ff_vc1_bfraction_bits, 1, 1,
1576 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1577 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1578 ff_vc1_norm2_bits, 1, 1,
1579 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1580 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1581 ff_vc1_norm6_bits, 1, 1,
1582 ff_vc1_norm6_codes, 2, 2, 556);
1583 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1584 ff_vc1_imode_bits, 1, 1,
1585 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1586 for (i = 0; i < 3; i++) {
1587 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1588 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1589 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1590 ff_vc1_ttmb_bits[i], 1, 1,
1591 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1592 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1593 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1594 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1595 ff_vc1_ttblk_bits[i], 1, 1,
1596 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1597 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1598 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1599 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1600 ff_vc1_subblkpat_bits[i], 1, 1,
1601 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1603 for (i = 0; i < 4; i++) {
1604 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1605 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1606 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1607 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1608 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1609 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1610 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1611 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1612 ff_vc1_cbpcy_p_bits[i], 1, 1,
1613 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1614 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1615 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1616 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1617 ff_vc1_mv_diff_bits[i], 1, 1,
1618 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1620 for (i = 0; i < 8; i++) {
1621 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1622 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1623 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1624 &vc1_ac_tables[i][0][1], 8, 4,
1625 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1626 /* initialize interlaced MVDATA tables (2-Ref) */
1627 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1628 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1629 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1630 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1631 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1633 for (i = 0; i < 4; i++) {
1634 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1635 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1636 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1637 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1638 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1639 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1640 /* initialize NON-4MV MBMODE VLC tables for the same */
1641 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1642 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1643 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1644 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1645 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1646 /* initialize interlaced MVDATA tables (1-Ref) */
1647 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1648 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1649 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1650 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1651 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1653 for (i = 0; i < 4; i++) {
1654 /* Initialize 2MV Block pattern VLC tables */
1655 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1656 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1657 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1658 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1659 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1661 for (i = 0; i < 8; i++) {
1662 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1663 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1664 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1665 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1666 ff_vc1_icbpcy_p_bits[i], 1, 1,
1667 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1668 /* Initialize interlaced field picture MBMODE VLC tables */
1669 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1670 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1671 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1672 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1673 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1674 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1675 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1676 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1677 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1678 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1683 /* Other defaults */
1685 v->mvrange = 0; /* 7.1.1.18, p80 */
1687 ff_vc1dsp_init(&v->vc1dsp);