2 * VC-1 and WMV3 decoder common code
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder common code
29 #include "libavutil/attributes.h"
30 #include "libavutil/thread.h"
33 #include "mpegvideo.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 v->dquantfrm = get_bits1(gb);
242 v->dqprofile = get_bits(gb, 2);
243 switch (v->dqprofile) {
244 case DQPROFILE_SINGLE_EDGE:
245 case DQPROFILE_DOUBLE_EDGES:
246 v->dqsbedge = get_bits(gb, 2);
248 case DQPROFILE_ALL_MBS:
249 v->dqbilevel = get_bits1(gb);
259 pqdiff = get_bits(gb, 3);
261 v->altpq = get_bits(gb, 5);
263 v->altpq = v->pq + pqdiff + 1;
268 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
271 * Decode Simple/Main Profiles sequence header
272 * @see Figure 7-8, p16-17
273 * @param avctx Codec context
274 * @param gb GetBit context initialized from Codec context extra_data
277 int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
279 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits_long(gb, 32));
280 v->profile = get_bits(gb, 2);
281 if (v->profile == PROFILE_COMPLEX) {
282 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
285 if (v->profile == PROFILE_ADVANCED) {
286 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
287 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
288 return decode_sequence_header_adv(v, gb);
291 v->zz_8x4 = ff_wmv2_scantableA;
292 v->zz_4x8 = ff_wmv2_scantableB;
293 v->res_y411 = get_bits1(gb);
294 v->res_sprite = get_bits1(gb);
296 av_log(avctx, AV_LOG_ERROR,
297 "Old interlaced mode is not supported\n");
303 v->frmrtq_postproc = get_bits(gb, 3); //common
304 // (bitrate-32kbps)/64kbps
305 v->bitrtq_postproc = get_bits(gb, 5); //common
306 v->s.loop_filter = get_bits1(gb); //common
307 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
308 av_log(avctx, AV_LOG_ERROR,
309 "LOOPFILTER shall not be enabled in Simple Profile\n");
311 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
312 v->s.loop_filter = 0;
314 v->res_x8 = get_bits1(gb); //reserved
315 v->multires = get_bits1(gb);
316 v->res_fasttx = get_bits1(gb);
317 if (!v->res_fasttx) {
318 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_int16_8bit;
319 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
320 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
321 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
322 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_int16_8bit;
323 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
324 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
325 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
328 v->fastuvmc = get_bits1(gb); //common
329 if (!v->profile && !v->fastuvmc) {
330 av_log(avctx, AV_LOG_ERROR,
331 "FASTUVMC unavailable in Simple Profile\n");
334 v->extended_mv = get_bits1(gb); //common
335 if (!v->profile && v->extended_mv) {
336 av_log(avctx, AV_LOG_ERROR,
337 "Extended MVs unavailable in Simple Profile\n");
340 v->dquant = get_bits(gb, 2); //common
341 v->vstransform = get_bits1(gb); //common
343 v->res_transtab = get_bits1(gb);
344 if (v->res_transtab) {
345 av_log(avctx, AV_LOG_ERROR,
346 "1 for reserved RES_TRANSTAB is forbidden\n");
350 v->overlap = get_bits1(gb); //common
352 v->resync_marker = get_bits1(gb);
353 v->rangered = get_bits1(gb);
354 if (v->rangered && v->profile == PROFILE_SIMPLE) {
355 av_log(avctx, AV_LOG_INFO,
356 "RANGERED should be set to 0 in Simple Profile\n");
359 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
360 v->quantizer_mode = get_bits(gb, 2); //common
362 v->finterpflag = get_bits1(gb); //common
365 int w = get_bits(gb, 11);
366 int h = get_bits(gb, 11);
367 int ret = ff_set_dimensions(v->s.avctx, w, h);
369 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
372 skip_bits(gb, 5); //frame rate
373 v->res_x8 = get_bits1(gb);
374 if (get_bits1(gb)) { // something to do with DC VLC selection
375 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
378 skip_bits(gb, 3); //slice code
381 v->res_rtm_flag = get_bits1(gb); //reserved
383 //TODO: figure out what they mean (always 0x402F)
386 av_log(avctx, AV_LOG_DEBUG,
387 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
388 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
389 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
390 "DQuant=%i, Quantizer mode=%i, Max B-frames=%i\n",
391 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
392 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
393 v->rangered, v->vstransform, v->overlap, v->resync_marker,
394 v->dquant, v->quantizer_mode, avctx->max_b_frames);
398 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
401 v->level = get_bits(gb, 3);
403 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
405 v->chromaformat = get_bits(gb, 2);
406 if (v->chromaformat != 1) {
407 av_log(v->s.avctx, AV_LOG_ERROR,
408 "Only 4:2:0 chroma format supported\n");
413 v->frmrtq_postproc = get_bits(gb, 3); //common
414 // (bitrate-32kbps)/64kbps
415 v->bitrtq_postproc = get_bits(gb, 5); //common
416 v->postprocflag = get_bits1(gb); //common
418 v->max_coded_width = (get_bits(gb, 12) + 1) << 1;
419 v->max_coded_height = (get_bits(gb, 12) + 1) << 1;
420 v->broadcast = get_bits1(gb);
421 v->interlace = get_bits1(gb);
422 v->tfcntrflag = get_bits1(gb);
423 v->finterpflag = get_bits1(gb);
424 skip_bits1(gb); // reserved
426 av_log(v->s.avctx, AV_LOG_DEBUG,
427 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
428 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
429 "TFCTRflag=%i, FINTERPflag=%i\n",
430 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
431 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
432 v->tfcntrflag, v->finterpflag);
434 v->psf = get_bits1(gb);
435 if (v->psf) { //PsF, 6.1.13
436 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
439 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
440 if (get_bits1(gb)) { //Display Info - decoding is not affected by it
442 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
443 w = get_bits(gb, 14) + 1;
444 h = get_bits(gb, 14) + 1;
445 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
447 ar = get_bits(gb, 4);
449 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
450 } else if (ar == 15) {
451 w = get_bits(gb, 8) + 1;
452 h = get_bits(gb, 8) + 1;
453 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
455 if (v->s.avctx->width > v->max_coded_width ||
456 v->s.avctx->height > v->max_coded_height) {
457 avpriv_request_sample(v->s.avctx, "Huge resolution");
459 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
460 &v->s.avctx->sample_aspect_ratio.den,
461 v->s.avctx->height * w,
462 v->s.avctx->width * h,
465 ff_set_sar(v->s.avctx, v->s.avctx->sample_aspect_ratio);
466 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
467 v->s.avctx->sample_aspect_ratio.num,
468 v->s.avctx->sample_aspect_ratio.den);
470 if (get_bits1(gb)) { //framerate stuff
472 v->s.avctx->framerate.den = 32;
473 v->s.avctx->framerate.num = get_bits(gb, 16) + 1;
476 nr = get_bits(gb, 8);
477 dr = get_bits(gb, 4);
478 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
479 v->s.avctx->framerate.den = ff_vc1_fps_dr[dr - 1];
480 v->s.avctx->framerate.num = ff_vc1_fps_nr[nr - 1] * 1000;
483 if (v->broadcast) { // Pulldown may be present
484 v->s.avctx->ticks_per_frame = 2;
489 v->color_prim = get_bits(gb, 8);
490 v->transfer_char = get_bits(gb, 8);
491 v->matrix_coef = get_bits(gb, 8);
495 v->hrd_param_flag = get_bits1(gb);
496 if (v->hrd_param_flag) {
498 v->hrd_num_leaky_buckets = get_bits(gb, 5);
499 skip_bits(gb, 4); //bitrate exponent
500 skip_bits(gb, 4); //buffer size exponent
501 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
502 skip_bits(gb, 16); //hrd_rate[n]
503 skip_bits(gb, 16); //hrd_buffer[n]
509 int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
515 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
516 v->broken_link = get_bits1(gb);
517 v->closed_entry = get_bits1(gb);
518 v->panscanflag = get_bits1(gb);
519 v->refdist_flag = get_bits1(gb);
520 v->s.loop_filter = get_bits1(gb);
521 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
522 v->s.loop_filter = 0;
523 v->fastuvmc = get_bits1(gb);
524 v->extended_mv = get_bits1(gb);
525 v->dquant = get_bits(gb, 2);
526 v->vstransform = get_bits1(gb);
527 v->overlap = get_bits1(gb);
528 v->quantizer_mode = get_bits(gb, 2);
530 if (v->hrd_param_flag) {
531 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
532 skip_bits(gb, 8); //hrd_full[n]
537 w = (get_bits(gb, 12)+1)<<1;
538 h = (get_bits(gb, 12)+1)<<1;
540 w = v->max_coded_width;
541 h = v->max_coded_height;
543 if ((ret = ff_set_dimensions(avctx, w, h)) < 0) {
544 av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", w, h);
549 v->extended_dmv = get_bits1(gb);
550 if ((v->range_mapy_flag = get_bits1(gb))) {
551 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
552 v->range_mapy = get_bits(gb, 3);
554 if ((v->range_mapuv_flag = get_bits1(gb))) {
555 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
556 v->range_mapuv = get_bits(gb, 3);
559 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
560 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
561 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
562 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
563 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
564 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
569 /* fill lookup tables for intensity compensation */
570 #define INIT_LUT(lumscale, lumshift, luty, lutuv, chain) do { \
571 int scale, shift, i; \
574 shift = (255 - lumshift * 2) * 64; \
578 scale = lumscale + 32; \
580 shift = (lumshift - 64) * 64; \
582 shift = lumshift << 6; \
584 for (i = 0; i < 256; i++) { \
585 int iy = chain ? luty[i] : i; \
586 int iu = chain ? lutuv[i] : i; \
587 luty[i] = av_clip_uint8((scale * iy + shift + 32) >> 6); \
588 lutuv[i] = av_clip_uint8((scale * (iu - 128) + 128*64 + 32) >> 6);\
592 static void rotate_luts(VC1Context *v)
594 #define ROTATE(DEF, L, N, C, A) do { \
595 if (v->s.pict_type == AV_PICTURE_TYPE_BI || v->s.pict_type == AV_PICTURE_TYPE_B) { \
599 memcpy(&tmp, L , sizeof(tmp)); \
600 memcpy(L , N , sizeof(tmp)); \
601 memcpy(N , &tmp, sizeof(tmp)); \
606 ROTATE(int tmp, &v->last_use_ic, &v->next_use_ic, v->curr_use_ic, &v->aux_use_ic);
607 ROTATE(uint8_t tmp[2][256], v->last_luty, v->next_luty, v->curr_luty, v->aux_luty);
608 ROTATE(uint8_t tmp[2][256], v->last_lutuv, v->next_lutuv, v->curr_lutuv, v->aux_lutuv);
610 INIT_LUT(32, 0, v->curr_luty[0], v->curr_lutuv[0], 0);
611 INIT_LUT(32, 0, v->curr_luty[1], v->curr_lutuv[1], 0);
615 static int read_bfraction(VC1Context *v, GetBitContext* gb) {
616 int bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
618 if (bfraction_lut_index == 21 || bfraction_lut_index < 0) {
619 av_log(v->s.avctx, AV_LOG_ERROR, "bfraction invalid\n");
620 return AVERROR_INVALIDDATA;
622 v->bfraction_lut_index = bfraction_lut_index;
623 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
627 int ff_vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
629 int pqindex, lowquant, status;
632 v->fcm = PROGRESSIVE;
634 v->interpfrm = get_bits1(gb);
635 if (!v->s.avctx->codec)
637 if (v->s.avctx->codec_id == AV_CODEC_ID_MSS2)
640 v->multires = get_bits(gb, 2) == 1;
642 skip_bits(gb, 2); //framecnt unused
645 v->rangeredfrm = get_bits1(gb);
647 v->s.pict_type = AV_PICTURE_TYPE_P;
649 if (v->s.avctx->max_b_frames && !get_bits1(gb)) {
650 v->s.pict_type = AV_PICTURE_TYPE_B;
652 v->s.pict_type = AV_PICTURE_TYPE_I;
656 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
657 if (read_bfraction(v, gb) < 0)
658 return AVERROR_INVALIDDATA;
659 if (v->bfraction == 0) {
660 v->s.pict_type = AV_PICTURE_TYPE_BI;
663 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
664 skip_bits(gb, 7); // skip buffer fullness
670 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
672 if (v->s.pict_type == AV_PICTURE_TYPE_P)
675 /* Quantizer stuff */
676 pqindex = get_bits(gb, 5);
679 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
680 v->pq = ff_vc1_pquant_table[0][pqindex];
682 v->pq = ff_vc1_pquant_table[1][pqindex];
683 v->pqindex = pqindex;
685 v->halfpq = get_bits1(gb);
688 switch (v->quantizer_mode) {
689 case QUANT_FRAME_IMPLICIT:
690 v->pquantizer = pqindex < 9;
692 case QUANT_NON_UNIFORM:
695 case QUANT_FRAME_EXPLICIT:
696 v->pquantizer = get_bits1(gb);
703 if (v->extended_mv == 1)
704 v->mvrange = get_unary(gb, 0, 3);
705 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
706 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
707 v->range_x = 1 << (v->k_x - 1);
708 v->range_y = 1 << (v->k_y - 1);
709 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
710 v->respic = get_bits(gb, 2);
712 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
713 v->x8_type = get_bits1(gb);
716 ff_dlog(v->s.avctx, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
717 (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'),
718 pqindex, v->pq, v->halfpq, v->rangeredfrm);
720 if (v->first_pic_header_flag)
723 switch (v->s.pict_type) {
724 case AV_PICTURE_TYPE_P:
725 v->tt_index = (v->pq > 4) + (v->pq > 12);
727 lowquant = (v->pq > 12) ? 0 : 1;
728 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
729 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
730 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
731 v->lumscale = get_bits(gb, 6);
732 v->lumshift = get_bits(gb, 6);
734 /* fill lookup tables for intensity compensation */
735 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
736 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
738 v->qs_last = v->s.quarter_sample;
739 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
740 v->s.quarter_sample = (v->mv_mode2 != MV_PMODE_1MV_HPEL &&
741 v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
742 v->s.mspel = (v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
744 v->s.quarter_sample = (v->mv_mode != MV_PMODE_1MV_HPEL &&
745 v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
746 v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
749 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
750 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
751 v->mv_mode == MV_PMODE_MIXED_MV) {
752 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
755 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
756 "Imode: %i, Invert: %i\n", status>>1, status&1);
758 v->mv_type_is_raw = 0;
759 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
761 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
764 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
765 "Imode: %i, Invert: %i\n", status>>1, status&1);
767 /* Hopefully this is correct for P-frames */
768 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
769 v->cbptab = get_bits(gb, 2);
770 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
773 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
774 vop_dquant_decoding(v);
777 if (v->vstransform) {
778 v->ttmbf = get_bits1(gb);
780 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
782 v->ttfrm = 0; //FIXME Is that so ?
788 case AV_PICTURE_TYPE_B:
789 v->tt_index = (v->pq > 4) + (v->pq > 12);
791 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
792 v->qs_last = v->s.quarter_sample;
793 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
794 v->s.mspel = v->s.quarter_sample;
796 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
799 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
800 "Imode: %i, Invert: %i\n", status>>1, status&1);
801 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
804 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
805 "Imode: %i, Invert: %i\n", status>>1, status&1);
807 v->s.mv_table_index = get_bits(gb, 2);
808 v->cbptab = get_bits(gb, 2);
809 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
812 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
813 vop_dquant_decoding(v);
816 if (v->vstransform) {
817 v->ttmbf = get_bits1(gb);
819 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
831 v->c_ac_table_index = decode012(gb);
832 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
833 v->y_ac_table_index = decode012(gb);
836 v->s.dc_table_index = get_bits1(gb);
839 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
840 v->s.pict_type = AV_PICTURE_TYPE_B;
846 int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
848 int pqindex, lowquant;
853 v->p_frame_skipped = 0;
854 if (v->second_field) {
855 if (v->fcm != ILACE_FIELD || v->field_mode!=1)
858 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
860 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
861 v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
862 if (!v->pic_header_flag)
863 goto parse_common_info;
870 if (fcm == ILACE_FIELD)
876 if (!v->first_pic_header_flag && v->field_mode != field_mode)
877 return AVERROR_INVALIDDATA;
878 v->field_mode = field_mode;
881 av_assert0( v->s.mb_height == v->s.height + 15 >> 4
882 || v->s.mb_height == FFALIGN(v->s.height + 15 >> 4, 2));
884 v->s.mb_height = FFALIGN(v->s.height + 15 >> 4, 2);
885 v->fptype = get_bits(gb, 3);
886 if (v->fptype & 4) // B-picture
887 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
889 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
891 v->s.mb_height = v->s.height + 15 >> 4;
892 switch (get_unary(gb, 0, 4)) {
894 v->s.pict_type = AV_PICTURE_TYPE_P;
897 v->s.pict_type = AV_PICTURE_TYPE_B;
900 v->s.pict_type = AV_PICTURE_TYPE_I;
903 v->s.pict_type = AV_PICTURE_TYPE_BI;
906 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
907 v->p_frame_skipped = 1;
914 if (!v->interlace || v->psf) {
915 v->rptfrm = get_bits(gb, 2);
917 v->tff = get_bits1(gb);
918 v->rff = get_bits1(gb);
923 if (v->panscanflag) {
924 avpriv_report_missing_feature(v->s.avctx, "Pan-scan");
927 if (v->p_frame_skipped) {
930 v->rnd = get_bits1(gb);
932 v->uvsamp = get_bits1(gb);
933 if(!ff_vc1_bfraction_vlc.table)
934 return 0; //parsing only, vlc tables havnt been allocated
936 if (!v->refdist_flag)
938 else if ((v->s.pict_type != AV_PICTURE_TYPE_B) && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
939 v->refdist = get_bits(gb, 2);
941 v->refdist += get_unary(gb, 0, 14);
943 return AVERROR_INVALIDDATA;
945 if ((v->s.pict_type == AV_PICTURE_TYPE_B) || (v->s.pict_type == AV_PICTURE_TYPE_BI)) {
946 if (read_bfraction(v, gb) < 0)
947 return AVERROR_INVALIDDATA;
948 v->frfd = (v->bfraction * v->refdist) >> 8;
949 v->brfd = v->refdist - v->frfd - 1;
953 goto parse_common_info;
955 if (v->fcm == PROGRESSIVE) {
957 v->interpfrm = get_bits1(gb);
958 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
959 if (read_bfraction(v, gb) < 0)
960 return AVERROR_INVALIDDATA;
961 if (v->bfraction == 0) {
962 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
969 v->cur_field_type = !(v->tff ^ v->second_field);
970 pqindex = get_bits(gb, 5);
973 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
974 v->pq = ff_vc1_pquant_table[0][pqindex];
976 v->pq = ff_vc1_pquant_table[1][pqindex];
977 v->pqindex = pqindex;
979 v->halfpq = get_bits1(gb);
982 switch (v->quantizer_mode) {
983 case QUANT_FRAME_IMPLICIT:
984 v->pquantizer = pqindex < 9;
986 case QUANT_NON_UNIFORM:
989 case QUANT_FRAME_EXPLICIT:
990 v->pquantizer = get_bits1(gb);
998 v->postproc = get_bits(gb, 2);
1003 if (v->first_pic_header_flag)
1006 switch (v->s.pict_type) {
1007 case AV_PICTURE_TYPE_I:
1008 case AV_PICTURE_TYPE_BI:
1009 if (v->fcm == ILACE_FRAME) { //interlace frame picture
1010 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
1013 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
1014 "Imode: %i, Invert: %i\n", status>>1, status&1);
1016 v->fieldtx_is_raw = 0;
1017 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1020 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1021 "Imode: %i, Invert: %i\n", status>>1, status&1);
1022 v->condover = CONDOVER_NONE;
1023 if (v->overlap && v->pq <= 8) {
1024 v->condover = decode012(gb);
1025 if (v->condover == CONDOVER_SELECT) {
1026 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1029 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1030 "Imode: %i, Invert: %i\n", status>>1, status&1);
1034 case AV_PICTURE_TYPE_P:
1035 if (v->field_mode) {
1036 v->numref = get_bits1(gb);
1038 v->reffield = get_bits1(gb);
1039 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
1043 v->mvrange = get_unary(gb, 0, 3);
1047 if (v->extended_dmv)
1048 v->dmvrange = get_unary(gb, 0, 3);
1051 if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1052 v->fourmvswitch = get_bits1(gb);
1053 v->intcomp = get_bits1(gb);
1055 v->lumscale = get_bits(gb, 6);
1056 v->lumshift = get_bits(gb, 6);
1057 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[0], v->last_lutuv[0], 1);
1058 INIT_LUT(v->lumscale, v->lumshift, v->last_luty[1], v->last_lutuv[1], 1);
1061 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1064 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1065 "Imode: %i, Invert: %i\n", status>>1, status&1);
1066 v->mbmodetab = get_bits(gb, 2);
1067 if (v->fourmvswitch)
1068 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[v->mbmodetab];
1070 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[v->mbmodetab];
1071 v->imvtab = get_bits(gb, 2);
1072 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1073 // interlaced p-picture cbpcy range is [1, 63]
1074 v->icbptab = get_bits(gb, 3);
1075 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1076 v->twomvbptab = get_bits(gb, 2);
1077 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[v->twomvbptab];
1078 if (v->fourmvswitch) {
1079 v->fourmvbptab = get_bits(gb, 2);
1080 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1084 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1085 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1086 v->range_x = 1 << (v->k_x - 1);
1087 v->range_y = 1 << (v->k_y - 1);
1089 v->tt_index = (v->pq > 4) + (v->pq > 12);
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_INTENSITY_COMP) {
1134 v->s.quarter_sample = (v->mv_mode2 != MV_PMODE_1MV_HPEL &&
1135 v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
1136 v->s.mspel = (v->mv_mode2 != MV_PMODE_1MV_HPEL_BILIN);
1138 v->s.quarter_sample = (v->mv_mode != MV_PMODE_1MV_HPEL &&
1139 v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1140 v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1143 if (v->fcm == PROGRESSIVE) { // progressive
1144 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1145 v->mv_mode2 == MV_PMODE_MIXED_MV)
1146 || v->mv_mode == MV_PMODE_MIXED_MV) {
1147 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1150 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1151 "Imode: %i, Invert: %i\n", status>>1, status&1);
1153 v->mv_type_is_raw = 0;
1154 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1156 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1159 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1160 "Imode: %i, Invert: %i\n", status>>1, status&1);
1162 /* Hopefully this is correct for P-frames */
1163 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1164 v->cbptab = get_bits(gb, 2);
1165 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
1166 } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1167 v->qs_last = v->s.quarter_sample;
1168 v->s.quarter_sample = 1;
1170 } else { // field interlaced
1171 v->mbmodetab = get_bits(gb, 3);
1172 v->imvtab = get_bits(gb, 2 + v->numref);
1174 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1176 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[v->imvtab];
1177 v->icbptab = get_bits(gb, 3);
1178 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1179 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1180 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
1181 v->fourmvbptab = get_bits(gb, 2);
1182 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1183 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[v->mbmodetab];
1185 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[v->mbmodetab];
1189 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1190 vop_dquant_decoding(v);
1193 if (v->vstransform) {
1194 v->ttmbf = get_bits1(gb);
1196 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1198 v->ttfrm = 0; //FIXME Is that so ?
1204 case AV_PICTURE_TYPE_B:
1205 if (v->fcm == ILACE_FRAME) {
1206 if (read_bfraction(v, gb) < 0)
1207 return AVERROR_INVALIDDATA;
1208 if (v->bfraction == 0) {
1213 v->mvrange = get_unary(gb, 0, 3);
1216 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1217 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1218 v->range_x = 1 << (v->k_x - 1);
1219 v->range_y = 1 << (v->k_y - 1);
1221 v->tt_index = (v->pq > 4) + (v->pq > 12);
1223 if (v->field_mode) {
1225 av_log(v->s.avctx, AV_LOG_DEBUG, "B Fields\n");
1226 if (v->extended_dmv)
1227 v->dmvrange = get_unary(gb, 0, 3);
1228 mvmode = get_unary(gb, 1, 3);
1229 lowquant = (v->pq > 12) ? 0 : 1;
1230 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1231 v->qs_last = v->s.quarter_sample;
1232 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
1233 v->s.mspel = (v->mv_mode != MV_PMODE_1MV_HPEL_BILIN);
1234 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1237 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1238 "Imode: %i, Invert: %i\n", status>>1, status&1);
1239 v->mbmodetab = get_bits(gb, 3);
1240 if (v->mv_mode == MV_PMODE_MIXED_MV)
1241 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[v->mbmodetab];
1243 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[v->mbmodetab];
1244 v->imvtab = get_bits(gb, 3);
1245 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[v->imvtab];
1246 v->icbptab = get_bits(gb, 3);
1247 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1248 if (v->mv_mode == MV_PMODE_MIXED_MV) {
1249 v->fourmvbptab = get_bits(gb, 2);
1250 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1252 v->numref = 1; // interlaced field B pictures are always 2-ref
1253 } else if (v->fcm == ILACE_FRAME) {
1254 if (v->extended_dmv)
1255 v->dmvrange = get_unary(gb, 0, 3);
1256 if (get_bits1(gb)) /* intcomp - present but shall always be 0 */
1257 av_log(v->s.avctx, AV_LOG_WARNING, "Intensity compensation set for B picture\n");
1259 v->mv_mode = MV_PMODE_1MV;
1260 v->fourmvswitch = 0;
1261 v->qs_last = v->s.quarter_sample;
1262 v->s.quarter_sample = 1;
1264 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1267 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1268 "Imode: %i, Invert: %i\n", status>>1, status&1);
1269 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1272 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1273 "Imode: %i, Invert: %i\n", status>>1, status&1);
1274 v->mbmodetab = get_bits(gb, 2);
1275 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[v->mbmodetab];
1276 v->imvtab = get_bits(gb, 2);
1277 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[v->imvtab];
1278 // interlaced p/b-picture cbpcy range is [1, 63]
1279 v->icbptab = get_bits(gb, 3);
1280 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[v->icbptab];
1281 v->twomvbptab = get_bits(gb, 2);
1282 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[v->twomvbptab];
1283 v->fourmvbptab = get_bits(gb, 2);
1284 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[v->fourmvbptab];
1286 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1287 v->qs_last = v->s.quarter_sample;
1288 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1289 v->s.mspel = v->s.quarter_sample;
1290 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1293 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1294 "Imode: %i, Invert: %i\n", status>>1, status&1);
1295 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1298 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1299 "Imode: %i, Invert: %i\n", status>>1, status&1);
1300 v->s.mv_table_index = get_bits(gb, 2);
1301 v->cbptab = get_bits(gb, 2);
1302 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[v->cbptab];
1306 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1307 vop_dquant_decoding(v);
1310 if (v->vstransform) {
1311 v->ttmbf = get_bits1(gb);
1313 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1325 v->c_ac_table_index = decode012(gb);
1326 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
1327 v->y_ac_table_index = decode012(gb);
1329 else if (v->fcm != PROGRESSIVE && !v->s.quarter_sample) {
1335 v->s.dc_table_index = get_bits1(gb);
1336 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
1338 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1339 vop_dquant_decoding(v);
1342 v->bi_type = (v->s.pict_type == AV_PICTURE_TYPE_BI);
1344 v->s.pict_type = AV_PICTURE_TYPE_B;
1349 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
1351 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
1352 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
1353 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
1354 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
1355 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
1356 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
1357 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
1358 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
1359 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
1360 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
1361 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
1362 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
1363 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
1364 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
1365 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
1366 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
1367 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
1368 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
1369 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
1370 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
1371 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
1372 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
1373 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
1374 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
1375 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
1376 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
1377 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
1378 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
1379 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
1380 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
1381 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
1384 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
1385 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
1386 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
1387 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
1388 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
1389 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
1390 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
1391 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
1392 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
1393 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
1394 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
1395 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
1396 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
1397 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
1398 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
1399 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
1400 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
1401 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
1402 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
1403 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
1404 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
1405 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
1406 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
1407 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
1408 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
1409 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
1410 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
1411 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
1415 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
1416 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
1417 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
1418 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
1419 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
1420 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
1421 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
1422 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
1423 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
1424 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
1425 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
1426 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
1427 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
1428 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
1429 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
1430 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
1431 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
1432 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
1433 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
1434 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
1435 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
1436 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
1440 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
1441 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
1442 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
1443 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
1444 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
1445 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
1446 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
1447 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
1448 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
1449 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
1450 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
1451 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
1452 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
1453 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
1454 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
1455 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
1456 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
1457 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
1458 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
1459 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
1460 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
1461 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
1462 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
1463 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
1464 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
1467 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
1468 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
1469 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
1470 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
1471 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
1472 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
1473 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
1474 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
1475 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
1476 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
1477 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
1478 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
1479 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
1480 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
1481 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
1482 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
1483 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1487 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
1488 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
1489 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
1490 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
1491 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
1492 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
1493 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
1494 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
1495 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
1496 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
1497 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
1498 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
1499 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
1500 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
1501 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
1502 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
1503 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
1507 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
1508 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
1509 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
1510 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
1511 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
1512 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
1513 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
1514 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
1515 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
1516 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
1517 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
1518 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
1519 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
1520 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
1521 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
1522 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
1523 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
1524 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
1525 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
1526 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
1527 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
1528 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
1529 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
1530 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
1531 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
1532 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
1533 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
1537 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
1538 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
1539 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
1540 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
1541 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
1542 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
1543 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
1544 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
1545 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
1546 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
1547 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
1548 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
1549 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
1550 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
1551 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
1552 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
1553 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
1554 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
1555 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
1556 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
1557 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
1558 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
1559 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
1560 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
1561 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
1562 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
1563 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
1564 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
1565 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
1570 static const uint16_t vlc_offs[] = {
1571 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
1572 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
1573 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
1574 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
1575 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
1576 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
1577 31714, 31746, 31778, 32306, 32340, 32372
1580 static av_cold void vc1_init_static(void)
1583 static VLC_TYPE vlc_table[32372][2];
1585 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
1586 ff_vc1_bfraction_bits, 1, 1,
1587 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
1588 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
1589 ff_vc1_norm2_bits, 1, 1,
1590 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
1591 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
1592 ff_vc1_norm6_bits, 1, 1,
1593 ff_vc1_norm6_codes, 2, 2, 556);
1594 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
1595 ff_vc1_imode_bits, 1, 1,
1596 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
1597 for (i = 0; i < 3; i++) {
1598 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
1599 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
1600 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
1601 ff_vc1_ttmb_bits[i], 1, 1,
1602 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1603 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
1604 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
1605 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
1606 ff_vc1_ttblk_bits[i], 1, 1,
1607 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1608 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
1609 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
1610 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
1611 ff_vc1_subblkpat_bits[i], 1, 1,
1612 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1614 for (i = 0; i < 4; i++) {
1615 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
1616 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
1617 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
1618 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
1619 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1620 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
1621 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
1622 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
1623 ff_vc1_cbpcy_p_bits[i], 1, 1,
1624 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1625 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
1626 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
1627 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
1628 ff_vc1_mv_diff_bits[i], 1, 1,
1629 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1631 for (i = 0; i < 8; i++) {
1632 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
1633 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
1634 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
1635 &vc1_ac_tables[i][0][1], 8, 4,
1636 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
1637 /* initialize interlaced MVDATA tables (2-Ref) */
1638 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
1639 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
1640 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
1641 ff_vc1_2ref_mvdata_bits[i], 1, 1,
1642 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1644 for (i = 0; i < 4; i++) {
1645 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
1646 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
1647 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
1648 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
1649 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
1650 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1651 /* initialize NON-4MV MBMODE VLC tables for the same */
1652 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
1653 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
1654 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
1655 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
1656 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1657 /* initialize interlaced MVDATA tables (1-Ref) */
1658 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
1659 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
1660 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
1661 ff_vc1_1ref_mvdata_bits[i], 1, 1,
1662 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
1664 for (i = 0; i < 4; i++) {
1665 /* Initialize 2MV Block pattern VLC tables */
1666 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
1667 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
1668 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
1669 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
1670 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1672 for (i = 0; i < 8; i++) {
1673 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
1674 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
1675 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
1676 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
1677 ff_vc1_icbpcy_p_bits[i], 1, 1,
1678 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
1679 /* Initialize interlaced field picture MBMODE VLC tables */
1680 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
1681 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
1682 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
1683 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
1684 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1685 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
1686 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
1687 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
1688 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
1689 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
1694 * Init VC-1 specific tables and VC1Context members
1695 * @param v The VC1Context to initialize
1698 av_cold int ff_vc1_init_common(VC1Context *v)
1700 static AVOnce init_static_once = AV_ONCE_INIT;
1702 v->hrd_rate = v->hrd_buffer = NULL;
1706 v->mvrange = 0; /* 7.1.1.18, p80 */
1708 ff_vc1dsp_init(&v->vc1dsp);
1711 ff_thread_once(&init_static_once, vc1_init_static);