1/* 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 6 * 7 * This file is part of Libav. 8 * 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. 13 * 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. 18 * 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 22 */ 23 24/** 25 * @file 26 * VC-1 and WMV3 decoder common code 27 * 28 */ 29 30#include "internal.h" 31#include "dsputil.h" 32#include "avcodec.h" 33#include "mpegvideo.h" 34#include "vc1.h" 35#include "vc1data.h" 36#include "msmpeg4data.h" 37#include "unary.h" 38#include "simple_idct.h" 39 40#undef NDEBUG 41#include <assert.h> 42 43/***********************************************************************/ 44/** 45 * @name VC-1 Bitplane decoding 46 * @see 8.7, p56 47 * @{ 48 */ 49 50/** 51 * Imode types 52 * @{ 53 */ 54enum Imode { 55 IMODE_RAW, 56 IMODE_NORM2, 57 IMODE_DIFF2, 58 IMODE_NORM6, 59 IMODE_DIFF6, 60 IMODE_ROWSKIP, 61 IMODE_COLSKIP 62}; 63/** @} */ //imode defines 64 65/** Decode rows by checking if they are skipped 66 * @param plane Buffer to store decoded bits 67 * @param[in] width Width of this buffer 68 * @param[in] height Height of this buffer 69 * @param[in] stride of this buffer 70 */ 71static void decode_rowskip(uint8_t* plane, int width, int height, int stride, 72 GetBitContext *gb) 73{ 74 int x, y; 75 76 for (y = 0; y < height; y++) { 77 if (!get_bits1(gb)) //rowskip 78 memset(plane, 0, width); 79 else 80 for (x = 0; x < width; x++) 81 plane[x] = get_bits1(gb); 82 plane += stride; 83 } 84} 85 86/** Decode columns by checking if they are skipped 87 * @param plane Buffer to store decoded bits 88 * @param[in] width Width of this buffer 89 * @param[in] height Height of this buffer 90 * @param[in] stride of this buffer 91 * @todo FIXME: Optimize 92 */ 93static void decode_colskip(uint8_t* plane, int width, int height, int stride, 94 GetBitContext *gb) 95{ 96 int x, y; 97 98 for (x = 0; x < width; x++) { 99 if (!get_bits1(gb)) //colskip 100 for (y = 0; y < height; y++) 101 plane[y*stride] = 0; 102 else 103 for (y = 0; y < height; y++) 104 plane[y*stride] = get_bits1(gb); 105 plane ++; 106 } 107} 108 109/** Decode a bitplane's bits 110 * @param data bitplane where to store the decode bits 111 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly 112 * @param v VC-1 context for bit reading and logging 113 * @return Status 114 * @todo FIXME: Optimize 115 */ 116static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v) 117{ 118 GetBitContext *gb = &v->s.gb; 119 120 int imode, x, y, code, offset; 121 uint8_t invert, *planep = data; 122 int width, height, stride; 123 124 width = v->s.mb_width; 125 height = v->s.mb_height >> v->field_mode; 126 stride = v->s.mb_stride; 127 invert = get_bits1(gb); 128 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1); 129 130 *raw_flag = 0; 131 switch (imode) { 132 case IMODE_RAW: 133 //Data is actually read in the MB layer (same for all tests == "raw") 134 *raw_flag = 1; //invert ignored 135 return invert; 136 case IMODE_DIFF2: 137 case IMODE_NORM2: 138 if ((height * width) & 1) { 139 *planep++ = get_bits1(gb); 140 offset = 1; 141 } 142 else 143 offset = 0; 144 // decode bitplane as one long line 145 for (y = offset; y < height * width; y += 2) { 146 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1); 147 *planep++ = code & 1; 148 offset++; 149 if (offset == width) { 150 offset = 0; 151 planep += stride - width; 152 } 153 *planep++ = code >> 1; 154 offset++; 155 if (offset == width) { 156 offset = 0; 157 planep += stride - width; 158 } 159 } 160 break; 161 case IMODE_DIFF6: 162 case IMODE_NORM6: 163 if (!(height % 3) && (width % 3)) { // use 2x3 decoding 164 for (y = 0; y < height; y += 3) { 165 for (x = width & 1; x < width; x += 2) { 166 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2); 167 if (code < 0) { 168 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n"); 169 return -1; 170 } 171 planep[x + 0] = (code >> 0) & 1; 172 planep[x + 1] = (code >> 1) & 1; 173 planep[x + 0 + stride] = (code >> 2) & 1; 174 planep[x + 1 + stride] = (code >> 3) & 1; 175 planep[x + 0 + stride * 2] = (code >> 4) & 1; 176 planep[x + 1 + stride * 2] = (code >> 5) & 1; 177 } 178 planep += stride * 3; 179 } 180 if (width & 1) 181 decode_colskip(data, 1, height, stride, &v->s.gb); 182 } else { // 3x2 183 planep += (height & 1) * stride; 184 for (y = height & 1; y < height; y += 2) { 185 for (x = width % 3; x < width; x += 3) { 186 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2); 187 if (code < 0) { 188 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n"); 189 return -1; 190 } 191 planep[x + 0] = (code >> 0) & 1; 192 planep[x + 1] = (code >> 1) & 1; 193 planep[x + 2] = (code >> 2) & 1; 194 planep[x + 0 + stride] = (code >> 3) & 1; 195 planep[x + 1 + stride] = (code >> 4) & 1; 196 planep[x + 2 + stride] = (code >> 5) & 1; 197 } 198 planep += stride * 2; 199 } 200 x = width % 3; 201 if (x) 202 decode_colskip(data, x, height, stride, &v->s.gb); 203 if (height & 1) 204 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb); 205 } 206 break; 207 case IMODE_ROWSKIP: 208 decode_rowskip(data, width, height, stride, &v->s.gb); 209 break; 210 case IMODE_COLSKIP: 211 decode_colskip(data, width, height, stride, &v->s.gb); 212 break; 213 default: 214 break; 215 } 216 217 /* Applying diff operator */ 218 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) { 219 planep = data; 220 planep[0] ^= invert; 221 for (x = 1; x < width; x++) 222 planep[x] ^= planep[x-1]; 223 for (y = 1; y < height; y++) { 224 planep += stride; 225 planep[0] ^= planep[-stride]; 226 for (x = 1; x < width; x++) { 227 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert; 228 else planep[x] ^= planep[x-1]; 229 } 230 } 231 } else if (invert) { 232 planep = data; 233 for (x = 0; x < stride * height; x++) 234 planep[x] = !planep[x]; //FIXME stride 235 } 236 return (imode << 1) + invert; 237} 238 239/** @} */ //Bitplane group 240 241/***********************************************************************/ 242/** VOP Dquant decoding 243 * @param v VC-1 Context 244 */ 245static int vop_dquant_decoding(VC1Context *v) 246{ 247 GetBitContext *gb = &v->s.gb; 248 int pqdiff; 249 250 //variable size 251 if (v->dquant == 2) { 252 pqdiff = get_bits(gb, 3); 253 if (pqdiff == 7) 254 v->altpq = get_bits(gb, 5); 255 else 256 v->altpq = v->pq + pqdiff + 1; 257 } else { 258 v->dquantfrm = get_bits1(gb); 259 if (v->dquantfrm) { 260 v->dqprofile = get_bits(gb, 2); 261 switch (v->dqprofile) { 262 case DQPROFILE_SINGLE_EDGE: 263 case DQPROFILE_DOUBLE_EDGES: 264 v->dqsbedge = get_bits(gb, 2); 265 break; 266 case DQPROFILE_ALL_MBS: 267 v->dqbilevel = get_bits1(gb); 268 if (!v->dqbilevel) 269 v->halfpq = 0; 270 default: 271 break; //Forbidden ? 272 } 273 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) { 274 pqdiff = get_bits(gb, 3); 275 if (pqdiff == 7) 276 v->altpq = get_bits(gb, 5); 277 else 278 v->altpq = v->pq + pqdiff + 1; 279 } 280 } 281 } 282 return 0; 283} 284 285static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb); 286 287/** 288 * Decode Simple/Main Profiles sequence header 289 * @see Figure 7-8, p16-17 290 * @param avctx Codec context 291 * @param gb GetBit context initialized from Codec context extra_data 292 * @return Status 293 */ 294int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb) 295{ 296 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32)); 297 v->profile = get_bits(gb, 2); 298 if (v->profile == PROFILE_COMPLEX) { 299 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n"); 300 } 301 302 if (v->profile == PROFILE_ADVANCED) { 303 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz; 304 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz; 305 return decode_sequence_header_adv(v, gb); 306 } else { 307 v->zz_8x4 = wmv2_scantableA; 308 v->zz_4x8 = wmv2_scantableB; 309 v->res_y411 = get_bits1(gb); 310 v->res_sprite = get_bits1(gb); 311 if (v->res_y411) { 312 av_log(avctx, AV_LOG_ERROR, 313 "Old interlaced mode is not supported\n"); 314 return -1; 315 } 316 } 317 318 // (fps-2)/4 (->30) 319 v->frmrtq_postproc = get_bits(gb, 3); //common 320 // (bitrate-32kbps)/64kbps 321 v->bitrtq_postproc = get_bits(gb, 5); //common 322 v->s.loop_filter = get_bits1(gb); //common 323 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) { 324 av_log(avctx, AV_LOG_ERROR, 325 "LOOPFILTER shall not be enabled in Simple Profile\n"); 326 } 327 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL) 328 v->s.loop_filter = 0; 329 330 v->res_x8 = get_bits1(gb); //reserved 331 v->multires = get_bits1(gb); 332 v->res_fasttx = get_bits1(gb); 333 if (!v->res_fasttx) { 334 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8; 335 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add; 336 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add; 337 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add; 338 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8; 339 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add; 340 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add; 341 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add; 342 } 343 344 v->fastuvmc = get_bits1(gb); //common 345 if (!v->profile && !v->fastuvmc) { 346 av_log(avctx, AV_LOG_ERROR, 347 "FASTUVMC unavailable in Simple Profile\n"); 348 return -1; 349 } 350 v->extended_mv = get_bits1(gb); //common 351 if (!v->profile && v->extended_mv) 352 { 353 av_log(avctx, AV_LOG_ERROR, 354 "Extended MVs unavailable in Simple Profile\n"); 355 return -1; 356 } 357 v->dquant = get_bits(gb, 2); //common 358 v->vstransform = get_bits1(gb); //common 359 360 v->res_transtab = get_bits1(gb); 361 if (v->res_transtab) 362 { 363 av_log(avctx, AV_LOG_ERROR, 364 "1 for reserved RES_TRANSTAB is forbidden\n"); 365 return -1; 366 } 367 368 v->overlap = get_bits1(gb); //common 369 370 v->s.resync_marker = get_bits1(gb); 371 v->rangered = get_bits1(gb); 372 if (v->rangered && v->profile == PROFILE_SIMPLE) { 373 av_log(avctx, AV_LOG_INFO, 374 "RANGERED should be set to 0 in Simple Profile\n"); 375 } 376 377 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common 378 v->quantizer_mode = get_bits(gb, 2); //common 379 380 v->finterpflag = get_bits1(gb); //common 381 382 if (v->res_sprite) { 383 v->s.avctx->width = v->s.avctx->coded_width = get_bits(gb, 11); 384 v->s.avctx->height = v->s.avctx->coded_height = get_bits(gb, 11); 385 skip_bits(gb, 5); //frame rate 386 v->res_x8 = get_bits1(gb); 387 if (get_bits1(gb)) { // something to do with DC VLC selection 388 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n"); 389 return -1; 390 } 391 skip_bits(gb, 3); //slice code 392 v->res_rtm_flag = 0; 393 } else { 394 v->res_rtm_flag = get_bits1(gb); //reserved 395 } 396 if (!v->res_rtm_flag) { 397// av_log(avctx, AV_LOG_ERROR, 398// "0 for reserved RES_RTM_FLAG is forbidden\n"); 399 av_log(avctx, AV_LOG_ERROR, 400 "Old WMV3 version detected, some frames may be decoded incorrectly\n"); 401 //return -1; 402 } 403 //TODO: figure out what they mean (always 0x402F) 404 if (!v->res_fasttx) 405 skip_bits(gb, 16); 406 av_log(avctx, AV_LOG_DEBUG, 407 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n" 408 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n" 409 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n" 410 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n", 411 v->profile, v->frmrtq_postproc, v->bitrtq_postproc, 412 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv, 413 v->rangered, v->vstransform, v->overlap, v->s.resync_marker, 414 v->dquant, v->quantizer_mode, avctx->max_b_frames); 415 return 0; 416} 417 418static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb) 419{ 420 v->res_rtm_flag = 1; 421 v->level = get_bits(gb, 3); 422 if (v->level >= 5) { 423 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level); 424 } 425 v->chromaformat = get_bits(gb, 2); 426 if (v->chromaformat != 1) { 427 av_log(v->s.avctx, AV_LOG_ERROR, 428 "Only 4:2:0 chroma format supported\n"); 429 return -1; 430 } 431 432 // (fps-2)/4 (->30) 433 v->frmrtq_postproc = get_bits(gb, 3); //common 434 // (bitrate-32kbps)/64kbps 435 v->bitrtq_postproc = get_bits(gb, 5); //common 436 v->postprocflag = get_bits1(gb); //common 437 438 v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1; 439 v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1; 440 v->s.avctx->width = v->s.avctx->coded_width; 441 v->s.avctx->height = v->s.avctx->coded_height; 442 v->broadcast = get_bits1(gb); 443 v->interlace = get_bits1(gb); 444 v->tfcntrflag = get_bits1(gb); 445 v->finterpflag = get_bits1(gb); 446 skip_bits1(gb); // reserved 447 448 av_log(v->s.avctx, AV_LOG_DEBUG, 449 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n" 450 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n" 451 "TFCTRflag=%i, FINTERPflag=%i\n", 452 v->level, v->frmrtq_postproc, v->bitrtq_postproc, 453 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace, 454 v->tfcntrflag, v->finterpflag); 455 456 v->psf = get_bits1(gb); 457 if (v->psf) { //PsF, 6.1.13 458 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n"); 459 return -1; 460 } 461 v->s.max_b_frames = v->s.avctx->max_b_frames = 7; 462 if (get_bits1(gb)) { //Display Info - decoding is not affected by it 463 int w, h, ar = 0; 464 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n"); 465 w = get_bits(gb, 14) + 1; 466 h = get_bits(gb, 14) + 1; 467 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h); 468 if (get_bits1(gb)) 469 ar = get_bits(gb, 4); 470 if (ar && ar < 14) { 471 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar]; 472 } else if (ar == 15) { 473 w = get_bits(gb, 8) + 1; 474 h = get_bits(gb, 8) + 1; 475 v->s.avctx->sample_aspect_ratio = (AVRational){w, h}; 476 } else { 477 av_reduce(&v->s.avctx->sample_aspect_ratio.num, 478 &v->s.avctx->sample_aspect_ratio.den, 479 v->s.avctx->height * w, 480 v->s.avctx->width * h, 481 1 << 30); 482 } 483 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n", 484 v->s.avctx->sample_aspect_ratio.num, 485 v->s.avctx->sample_aspect_ratio.den); 486 487 if (get_bits1(gb)) { //framerate stuff 488 if (get_bits1(gb)) { 489 v->s.avctx->time_base.num = 32; 490 v->s.avctx->time_base.den = get_bits(gb, 16) + 1; 491 } else { 492 int nr, dr; 493 nr = get_bits(gb, 8); 494 dr = get_bits(gb, 4); 495 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) { 496 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1]; 497 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000; 498 } 499 } 500 if (v->broadcast) { // Pulldown may be present 501 v->s.avctx->time_base.den *= 2; 502 v->s.avctx->ticks_per_frame = 2; 503 } 504 } 505 506 if (get_bits1(gb)) { 507 v->color_prim = get_bits(gb, 8); 508 v->transfer_char = get_bits(gb, 8); 509 v->matrix_coef = get_bits(gb, 8); 510 } 511 } 512 513 v->hrd_param_flag = get_bits1(gb); 514 if (v->hrd_param_flag) { 515 int i; 516 v->hrd_num_leaky_buckets = get_bits(gb, 5); 517 skip_bits(gb, 4); //bitrate exponent 518 skip_bits(gb, 4); //buffer size exponent 519 for (i = 0; i < v->hrd_num_leaky_buckets; i++) { 520 skip_bits(gb, 16); //hrd_rate[n] 521 skip_bits(gb, 16); //hrd_buffer[n] 522 } 523 } 524 return 0; 525} 526 527int vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb) 528{ 529 int i; 530 531 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32)); 532 v->broken_link = get_bits1(gb); 533 v->closed_entry = get_bits1(gb); 534 v->panscanflag = get_bits1(gb); 535 v->refdist_flag = get_bits1(gb); 536 v->s.loop_filter = get_bits1(gb); 537 v->fastuvmc = get_bits1(gb); 538 v->extended_mv = get_bits1(gb); 539 v->dquant = get_bits(gb, 2); 540 v->vstransform = get_bits1(gb); 541 v->overlap = get_bits1(gb); 542 v->quantizer_mode = get_bits(gb, 2); 543 544 if (v->hrd_param_flag) { 545 for (i = 0; i < v->hrd_num_leaky_buckets; i++) { 546 skip_bits(gb, 8); //hrd_full[n] 547 } 548 } 549 550 if (get_bits1(gb)) { 551 avctx->width = avctx->coded_width = (get_bits(gb, 12) + 1) << 1; 552 avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1; 553 } 554 if (v->extended_mv) 555 v->extended_dmv = get_bits1(gb); 556 if ((v->range_mapy_flag = get_bits1(gb))) { 557 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n"); 558 v->range_mapy = get_bits(gb, 3); 559 } 560 if ((v->range_mapuv_flag = get_bits1(gb))) { 561 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n"); 562 v->range_mapuv = get_bits(gb, 3); 563 } 564 565 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n" 566 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n" 567 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n" 568 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n", 569 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter, 570 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode); 571 572 return 0; 573} 574 575int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb) 576{ 577 int pqindex, lowquant, status; 578 579 if (v->finterpflag) 580 v->interpfrm = get_bits1(gb); 581 skip_bits(gb, 2); //framecnt unused 582 v->rangeredfrm = 0; 583 if (v->rangered) 584 v->rangeredfrm = get_bits1(gb); 585 v->s.pict_type = get_bits1(gb); 586 if (v->s.avctx->max_b_frames) { 587 if (!v->s.pict_type) { 588 if (get_bits1(gb)) 589 v->s.pict_type = AV_PICTURE_TYPE_I; 590 else 591 v->s.pict_type = AV_PICTURE_TYPE_B; 592 } else 593 v->s.pict_type = AV_PICTURE_TYPE_P; 594 } else 595 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I; 596 597 v->bi_type = 0; 598 if (v->s.pict_type == AV_PICTURE_TYPE_B) { 599 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1); 600 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index]; 601 if (v->bfraction == 0) { 602 v->s.pict_type = AV_PICTURE_TYPE_BI; 603 } 604 } 605 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) 606 skip_bits(gb, 7); // skip buffer fullness 607 608 if (v->parse_only) 609 return 0; 610 611 /* calculate RND */ 612 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) 613 v->rnd = 1; 614 if (v->s.pict_type == AV_PICTURE_TYPE_P) 615 v->rnd ^= 1; 616 617 /* Quantizer stuff */ 618 pqindex = get_bits(gb, 5); 619 if (!pqindex) 620 return -1; 621 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT) 622 v->pq = ff_vc1_pquant_table[0][pqindex]; 623 else 624 v->pq = ff_vc1_pquant_table[1][pqindex]; 625 626 v->pquantizer = 1; 627 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT) 628 v->pquantizer = pqindex < 9; 629 if (v->quantizer_mode == QUANT_NON_UNIFORM) 630 v->pquantizer = 0; 631 v->pqindex = pqindex; 632 if (pqindex < 9) 633 v->halfpq = get_bits1(gb); 634 else 635 v->halfpq = 0; 636 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT) 637 v->pquantizer = get_bits1(gb); 638 v->dquantfrm = 0; 639 if (v->extended_mv == 1) 640 v->mvrange = get_unary(gb, 0, 3); 641 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13 642 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11 643 v->range_x = 1 << (v->k_x - 1); 644 v->range_y = 1 << (v->k_y - 1); 645 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B) 646 v->respic = get_bits(gb, 2); 647 648 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) { 649 v->x8_type = get_bits1(gb); 650 } else 651 v->x8_type = 0; 652//av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n", 653// (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm); 654 655 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P) 656 v->use_ic = 0; 657 658 switch (v->s.pict_type) { 659 case AV_PICTURE_TYPE_P: 660 if (v->pq < 5) v->tt_index = 0; 661 else if (v->pq < 13) v->tt_index = 1; 662 else v->tt_index = 2; 663 664 lowquant = (v->pq > 12) ? 0 : 1; 665 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)]; 666 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) { 667 int scale, shift, i; 668 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)]; 669 v->lumscale = get_bits(gb, 6); 670 v->lumshift = get_bits(gb, 6); 671 v->use_ic = 1; 672 /* fill lookup tables for intensity compensation */ 673 if (!v->lumscale) { 674 scale = -64; 675 shift = (255 - v->lumshift * 2) << 6; 676 if (v->lumshift > 31) 677 shift += 128 << 6; 678 } else { 679 scale = v->lumscale + 32; 680 if (v->lumshift > 31) 681 shift = (v->lumshift - 64) << 6; 682 else 683 shift = v->lumshift << 6; 684 } 685 for (i = 0; i < 256; i++) { 686 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); 687 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); 688 } 689 } 690 v->qs_last = v->s.quarter_sample; 691 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN) 692 v->s.quarter_sample = 0; 693 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) { 694 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN) 695 v->s.quarter_sample = 0; 696 else 697 v->s.quarter_sample = 1; 698 } else 699 v->s.quarter_sample = 1; 700 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)); 701 702 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP && 703 v->mv_mode2 == MV_PMODE_MIXED_MV) || 704 v->mv_mode == MV_PMODE_MIXED_MV) { 705 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v); 706 if (status < 0) 707 return -1; 708 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: " 709 "Imode: %i, Invert: %i\n", status>>1, status&1); 710 } else { 711 v->mv_type_is_raw = 0; 712 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height); 713 } 714 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v); 715 if (status < 0) 716 return -1; 717 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: " 718 "Imode: %i, Invert: %i\n", status>>1, status&1); 719 720 /* Hopefully this is correct for P frames */ 721 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables 722 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)]; 723 724 if (v->dquant) { 725 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n"); 726 vop_dquant_decoding(v); 727 } 728 729 v->ttfrm = 0; //FIXME Is that so ? 730 if (v->vstransform) { 731 v->ttmbf = get_bits1(gb); 732 if (v->ttmbf) { 733 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)]; 734 } 735 } else { 736 v->ttmbf = 1; 737 v->ttfrm = TT_8X8; 738 } 739 break; 740 case AV_PICTURE_TYPE_B: 741 if (v->pq < 5) v->tt_index = 0; 742 else if (v->pq < 13) v->tt_index = 1; 743 else v->tt_index = 2; 744 745 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN; 746 v->qs_last = v->s.quarter_sample; 747 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV); 748 v->s.mspel = v->s.quarter_sample; 749 750 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v); 751 if (status < 0) 752 return -1; 753 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: " 754 "Imode: %i, Invert: %i\n", status>>1, status&1); 755 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v); 756 if (status < 0) 757 return -1; 758 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: " 759 "Imode: %i, Invert: %i\n", status>>1, status&1); 760 761 v->s.mv_table_index = get_bits(gb, 2); 762 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)]; 763 764 if (v->dquant) { 765 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n"); 766 vop_dquant_decoding(v); 767 } 768 769 v->ttfrm = 0; 770 if (v->vstransform) { 771 v->ttmbf = get_bits1(gb); 772 if (v->ttmbf) { 773 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)]; 774 } 775 } else { 776 v->ttmbf = 1; 777 v->ttfrm = TT_8X8; 778 } 779 break; 780 } 781 782 if (!v->x8_type) { 783 /* AC Syntax */ 784 v->c_ac_table_index = decode012(gb); 785 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) { 786 v->y_ac_table_index = decode012(gb); 787 } 788 /* DC Syntax */ 789 v->s.dc_table_index = get_bits1(gb); 790 } 791 792 if (v->s.pict_type == AV_PICTURE_TYPE_BI) { 793 v->s.pict_type = AV_PICTURE_TYPE_B; 794 v->bi_type = 1; 795 } 796 return 0; 797} 798 799/* fill lookup tables for intensity compensation */ 800#define INIT_LUT(lumscale, lumshift, luty, lutuv) \ 801 if (!lumscale) { \ 802 scale = -64; \ 803 shift = (255 - lumshift * 2) << 6; \ 804 if (lumshift > 31) \ 805 shift += 128 << 6; \ 806 } else { \ 807 scale = lumscale + 32; \ 808 if (lumshift > 31) \ 809 shift = (lumshift - 64) << 6; \ 810 else \ 811 shift = lumshift << 6; \ 812 } \ 813 for (i = 0; i < 256; i++) { \ 814 luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); \ 815 lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); \ 816 } 817 818int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb) 819{ 820 int pqindex, lowquant; 821 int status; 822 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */ 823 int scale, shift, i; /* for initializing LUT for intensity compensation */ 824 825 v->p_frame_skipped = 0; 826 if (v->second_field) { 827 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I; 828 if (v->fptype & 4) 829 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B; 830 v->s.current_picture_ptr->f.pict_type = v->s.pict_type; 831 if (!v->pic_header_flag) 832 goto parse_common_info; 833 } 834 835 v->field_mode = 0; 836 if (v->interlace) { 837 v->fcm = decode012(gb); 838 if (v->fcm) { 839 if (v->fcm == ILACE_FIELD) 840 v->field_mode = 1; 841 if (!v->warn_interlaced++) 842 av_log(v->s.avctx, AV_LOG_ERROR, 843 "Interlaced frames/fields support is incomplete\n"); 844 } 845 } else { 846 v->fcm = PROGRESSIVE; 847 } 848 849 if (v->field_mode) { 850 v->fptype = get_bits(gb, 3); 851 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I; 852 if (v->fptype & 4) // B-picture 853 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B; 854 } else { 855 switch (get_unary(gb, 0, 4)) { 856 case 0: 857 v->s.pict_type = AV_PICTURE_TYPE_P; 858 break; 859 case 1: 860 v->s.pict_type = AV_PICTURE_TYPE_B; 861 break; 862 case 2: 863 v->s.pict_type = AV_PICTURE_TYPE_I; 864 break; 865 case 3: 866 v->s.pict_type = AV_PICTURE_TYPE_BI; 867 break; 868 case 4: 869 v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic 870 v->p_frame_skipped = 1; 871 break; 872 } 873 } 874 if (v->tfcntrflag) 875 skip_bits(gb, 8); 876 if (v->broadcast) { 877 if (!v->interlace || v->psf) { 878 v->rptfrm = get_bits(gb, 2); 879 } else { 880 v->tff = get_bits1(gb); 881 v->rff = get_bits1(gb); 882 } 883 } 884 if (v->panscanflag) { 885 av_log_missing_feature(v->s.avctx, "Pan-scan", 0); 886 //... 887 } 888 if (v->p_frame_skipped) { 889 return 0; 890 } 891 v->rnd = get_bits1(gb); 892 if (v->interlace) 893 v->uvsamp = get_bits1(gb); 894 if (v->field_mode) { 895 if (!v->refdist_flag) 896 v->refdist = 0; 897 else { 898 if ((v->s.pict_type != AV_PICTURE_TYPE_B) 899 && (v->s.pict_type != AV_PICTURE_TYPE_BI)) { 900 v->refdist = get_bits(gb, 2); 901 if (v->refdist == 3) 902 v->refdist += get_unary(gb, 0, 16); 903 } else { 904 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1); 905 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index]; 906 v->frfd = (v->bfraction * v->refdist) >> 8; 907 v->brfd = v->refdist - v->frfd - 1; 908 if (v->brfd < 0) 909 v->brfd = 0; 910 } 911 } 912 goto parse_common_info; 913 } 914 if (v->finterpflag) 915 v->interpfrm = get_bits1(gb); 916 if (v->s.pict_type == AV_PICTURE_TYPE_B) { 917 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1); 918 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index]; 919 if (v->bfraction == 0) { 920 v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */ 921 } 922 } 923 924 parse_common_info: 925 if (v->field_mode) 926 v->cur_field_type = !(v->tff ^ v->second_field); 927 pqindex = get_bits(gb, 5); 928 if (!pqindex) 929 return -1; 930 v->pqindex = pqindex; 931 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT) 932 v->pq = ff_vc1_pquant_table[0][pqindex]; 933 else 934 v->pq = ff_vc1_pquant_table[1][pqindex]; 935 936 v->pquantizer = 1; 937 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT) 938 v->pquantizer = pqindex < 9; 939 if (v->quantizer_mode == QUANT_NON_UNIFORM) 940 v->pquantizer = 0; 941 v->pqindex = pqindex; 942 if (pqindex < 9) 943 v->halfpq = get_bits1(gb); 944 else 945 v->halfpq = 0; 946 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT) 947 v->pquantizer = get_bits1(gb); 948 if (v->postprocflag) 949 v->postproc = get_bits(gb, 2); 950 951 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P) 952 v->use_ic = 0; 953 954 if (v->parse_only) 955 return 0; 956 957 switch (v->s.pict_type) { 958 case AV_PICTURE_TYPE_I: 959 case AV_PICTURE_TYPE_BI: 960 if (v->fcm == ILACE_FRAME) { //interlace frame picture 961 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v); 962 if (status < 0) 963 return -1; 964 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: " 965 "Imode: %i, Invert: %i\n", status>>1, status&1); 966 } 967 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v); 968 if (status < 0) 969 return -1; 970 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: " 971 "Imode: %i, Invert: %i\n", status>>1, status&1); 972 v->condover = CONDOVER_NONE; 973 if (v->overlap && v->pq <= 8) { 974 v->condover = decode012(gb); 975 if (v->condover == CONDOVER_SELECT) { 976 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v); 977 if (status < 0) 978 return -1; 979 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: " 980 "Imode: %i, Invert: %i\n", status>>1, status&1); 981 } 982 } 983 break; 984 case AV_PICTURE_TYPE_P: 985 if (v->field_mode) { 986 v->numref = get_bits1(gb); 987 if (!v->numref) { 988 v->reffield = get_bits1(gb); 989 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type; 990 } 991 } 992 if (v->extended_mv) 993 v->mvrange = get_unary(gb, 0, 3); 994 else 995 v->mvrange = 0; 996 if (v->interlace) { 997 if (v->extended_dmv) 998 v->dmvrange = get_unary(gb, 0, 3); 999 else 1000 v->dmvrange = 0; 1001 if (v->fcm == ILACE_FRAME) { // interlaced frame picture 1002 v->fourmvswitch = get_bits1(gb); 1003 v->intcomp = get_bits1(gb); 1004 if (v->intcomp) { 1005 v->lumscale = get_bits(gb, 6); 1006 v->lumshift = get_bits(gb, 6); 1007 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv); 1008 } 1009 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v); 1010 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: " 1011 "Imode: %i, Invert: %i\n", status>>1, status&1); 1012 mbmodetab = get_bits(gb, 2); 1013 if (v->fourmvswitch) 1014 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab]; 1015 else 1016 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab]; 1017 imvtab = get_bits(gb, 2); 1018 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab]; 1019 // interlaced p-picture cbpcy range is [1, 63] 1020 icbptab = get_bits(gb, 3); 1021 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab]; 1022 twomvbptab = get_bits(gb, 2); 1023 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab]; 1024 if (v->fourmvswitch) { 1025 fourmvbptab = get_bits(gb, 2); 1026 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab]; 1027 } 1028 } 1029 } 1030 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13 1031 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11 1032 v->range_x = 1 << (v->k_x - 1); 1033 v->range_y = 1 << (v->k_y - 1); 1034 1035 if (v->pq < 5) 1036 v->tt_index = 0; 1037 else if (v->pq < 13) 1038 v->tt_index = 1; 1039 else 1040 v->tt_index = 2; 1041 if (v->fcm != ILACE_FRAME) { 1042 int mvmode; 1043 mvmode = get_unary(gb, 1, 4); 1044 lowquant = (v->pq > 12) ? 0 : 1; 1045 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode]; 1046 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) { 1047 int mvmode2; 1048 mvmode2 = get_unary(gb, 1, 3); 1049 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2]; 1050 if (v->field_mode) 1051 v->intcompfield = decode210(gb); 1052 v->lumscale = get_bits(gb, 6); 1053 v->lumshift = get_bits(gb, 6); 1054 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv); 1055 if ((v->field_mode) && !v->intcompfield) { 1056 v->lumscale2 = get_bits(gb, 6); 1057 v->lumshift2 = get_bits(gb, 6); 1058 INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2); 1059 } 1060 v->use_ic = 1; 1061 } 1062 v->qs_last = v->s.quarter_sample; 1063 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN) 1064 v->s.quarter_sample = 0; 1065 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) { 1066 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN) 1067 v->s.quarter_sample = 0; 1068 else 1069 v->s.quarter_sample = 1; 1070 } else 1071 v->s.quarter_sample = 1; 1072 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN 1073 || (v->mv_mode == MV_PMODE_INTENSITY_COMP 1074 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)); 1075 } 1076 if (v->fcm == PROGRESSIVE) { // progressive 1077 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP && 1078 v->mv_mode2 == MV_PMODE_MIXED_MV) 1079 || v->mv_mode == MV_PMODE_MIXED_MV) { 1080 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v); 1081 if (status < 0) 1082 return -1; 1083 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: " 1084 "Imode: %i, Invert: %i\n", status>>1, status&1); 1085 } else { 1086 v->mv_type_is_raw = 0; 1087 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height); 1088 } 1089 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v); 1090 if (status < 0) 1091 return -1; 1092 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: " 1093 "Imode: %i, Invert: %i\n", status>>1, status&1); 1094 1095 /* Hopefully this is correct for P frames */ 1096 v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables 1097 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)]; 1098 } else if (v->fcm == ILACE_FRAME) { // frame interlaced 1099 v->qs_last = v->s.quarter_sample; 1100 v->s.quarter_sample = 1; 1101 v->s.mspel = 1; 1102 } else { // field interlaced 1103 mbmodetab = get_bits(gb, 3); 1104 imvtab = get_bits(gb, 2 + v->numref); 1105 if (!v->numref) 1106 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab]; 1107 else 1108 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab]; 1109 icbptab = get_bits(gb, 3); 1110 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab]; 1111 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP && 1112 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) { 1113 fourmvbptab = get_bits(gb, 2); 1114 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab]; 1115 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab]; 1116 } else { 1117 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab]; 1118 } 1119 } 1120 if (v->dquant) { 1121 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n"); 1122 vop_dquant_decoding(v); 1123 } 1124 1125 v->ttfrm = 0; //FIXME Is that so ? 1126 if (v->vstransform) { 1127 v->ttmbf = get_bits1(gb); 1128 if (v->ttmbf) { 1129 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)]; 1130 } 1131 } else { 1132 v->ttmbf = 1; 1133 v->ttfrm = TT_8X8; 1134 } 1135 break; 1136 case AV_PICTURE_TYPE_B: 1137 // TODO: implement interlaced frame B picture decoding 1138 if (v->fcm == ILACE_FRAME) 1139 return -1; 1140 if (v->extended_mv) 1141 v->mvrange = get_unary(gb, 0, 3); 1142 else 1143 v->mvrange = 0; 1144 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13 1145 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11 1146 v->range_x = 1 << (v->k_x - 1); 1147 v->range_y = 1 << (v->k_y - 1); 1148 1149 if (v->pq < 5) 1150 v->tt_index = 0; 1151 else if (v->pq < 13) 1152 v->tt_index = 1; 1153 else 1154 v->tt_index = 2; 1155 1156 if (v->field_mode) { 1157 int mvmode; 1158 if (v->extended_dmv) 1159 v->dmvrange = get_unary(gb, 0, 3); 1160 mvmode = get_unary(gb, 1, 3); 1161 lowquant = (v->pq > 12) ? 0 : 1; 1162 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode]; 1163 v->qs_last = v->s.quarter_sample; 1164 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV); 1165 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL); 1166 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v); 1167 if (status < 0) 1168 return -1; 1169 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: " 1170 "Imode: %i, Invert: %i\n", status>>1, status&1); 1171 mbmodetab = get_bits(gb, 3); 1172 if (v->mv_mode == MV_PMODE_MIXED_MV) 1173 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab]; 1174 else 1175 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab]; 1176 imvtab = get_bits(gb, 3); 1177 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab]; 1178 icbptab = get_bits(gb, 3); 1179 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab]; 1180 if (v->mv_mode == MV_PMODE_MIXED_MV) { 1181 fourmvbptab = get_bits(gb, 2); 1182 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab]; 1183 } 1184 v->numref = 1; // interlaced field B pictures are always 2-ref 1185 } else { 1186 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN; 1187 v->qs_last = v->s.quarter_sample; 1188 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV); 1189 v->s.mspel = v->s.quarter_sample; 1190 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v); 1191 if (status < 0) 1192 return -1; 1193 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: " 1194 "Imode: %i, Invert: %i\n", status>>1, status&1); 1195 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v); 1196 if (status < 0) 1197 return -1; 1198 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: " 1199 "Imode: %i, Invert: %i\n", status>>1, status&1); 1200 v->s.mv_table_index = get_bits(gb, 2); 1201 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)]; 1202 } 1203 1204 if (v->dquant) { 1205 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n"); 1206 vop_dquant_decoding(v); 1207 } 1208 1209 v->ttfrm = 0; 1210 if (v->vstransform) { 1211 v->ttmbf = get_bits1(gb); 1212 if (v->ttmbf) { 1213 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)]; 1214 } 1215 } else { 1216 v->ttmbf = 1; 1217 v->ttfrm = TT_8X8; 1218 } 1219 break; 1220 } 1221 1222 /* AC Syntax */ 1223 v->c_ac_table_index = decode012(gb); 1224 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) { 1225 v->y_ac_table_index = decode012(gb); 1226 } 1227 /* DC Syntax */ 1228 v->s.dc_table_index = get_bits1(gb); 1229 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) 1230 && v->dquant) { 1231 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n"); 1232 vop_dquant_decoding(v); 1233 } 1234 1235 v->bi_type = 0; 1236 if (v->s.pict_type == AV_PICTURE_TYPE_BI) { 1237 v->s.pict_type = AV_PICTURE_TYPE_B; 1238 v->bi_type = 1; 1239 } 1240 return 0; 1241} 1242 1243static const uint32_t vc1_ac_tables[AC_MODES][186][2] = { 1244{ 1245{ 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7}, 1246{ 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10}, 1247{ 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14}, 1248{ 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9}, 1249{ 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13}, 1250{ 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7}, 1251{ 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13}, 1252{ 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7}, 1253{ 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13}, 1254{ 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11}, 1255{ 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11}, 1256{ 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14}, 1257{ 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10}, 1258{ 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14}, 1259{ 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13}, 1260{ 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11}, 1261{ 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14}, 1262{ 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12}, 1263{ 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13}, 1264{ 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4}, 1265{ 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5}, 1266{ 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10}, 1267{ 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14}, 1268{ 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8}, 1269{ 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8}, 1270{ 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8}, 1271{ 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9}, 1272{ 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11}, 1273{ 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12}, 1274{ 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13}, 1275{ 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9} 1276}, 1277{ 1278{ 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7}, 1279{ 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11}, 1280{ 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13}, 1281{ 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4}, 1282{ 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11}, 1283{ 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7}, 1284{ 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15}, 1285{ 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14}, 1286{ 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14}, 1287{ 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7}, 1288{ 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13}, 1289{ 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11}, 1290{ 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13}, 1291{ 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10}, 1292{ 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12}, 1293{ 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14}, 1294{ 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8}, 1295{ 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15}, 1296{ 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4}, 1297{ 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12}, 1298{ 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10}, 1299{ 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12}, 1300{ 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13}, 1301{ 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12}, 1302{ 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10}, 1303{ 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11}, 1304{ 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14}, 1305{ 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14}, 1306{ 0x0169, 9} 1307}, 1308{ 1309{ 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7}, 1310{ 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10}, 1311{ 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5}, 1312{ 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11}, 1313{ 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8}, 1314{ 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5}, 1315{ 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13}, 1316{ 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6}, 1317{ 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11}, 1318{ 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10}, 1319{ 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10}, 1320{ 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11}, 1321{ 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12}, 1322{ 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11}, 1323{ 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5}, 1324{ 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12}, 1325{ 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7}, 1326{ 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8}, 1327{ 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8}, 1328{ 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9}, 1329{ 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12}, 1330{ 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13}, 1331{ 0x0016, 7} 1332}, 1333{ 1334{ 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10}, 1335{ 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14}, 1336{ 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11}, 1337{ 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5}, 1338{ 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9}, 1339{ 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14}, 1340{ 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11}, 1341{ 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11}, 1342{ 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12}, 1343{ 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12}, 1344{ 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9}, 1345{ 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11}, 1346{ 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12}, 1347{ 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10}, 1348{ 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15}, 1349{ 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15}, 1350{ 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12}, 1351{ 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13}, 1352{ 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12}, 1353{ 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15}, 1354{ 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10}, 1355{ 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9}, 1356{ 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13}, 1357{ 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14}, 1358{ 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9} 1359}, 1360{ 1361{ 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6}, 1362{ 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8}, 1363{ 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10}, 1364{ 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11}, 1365{ 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7}, 1366{ 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12}, 1367{ 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12}, 1368{ 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9}, 1369{ 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9}, 1370{ 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10}, 1371{ 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10}, 1372{ 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10}, 1373{ 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10}, 1374{ 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11}, 1375{ 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8}, 1376{ 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9}, 1377{ 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12}, 1378{ 0x0003, 7} 1379}, 1380{ 1381{ 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9}, 1382{ 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, 1383{ 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12}, 1384{ 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9}, 1385{ 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10}, 1386{ 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10}, 1387{ 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12}, 1388{ 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9}, 1389{ 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9}, 1390{ 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9}, 1391{ 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6}, 1392{ 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8}, 1393{ 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8}, 1394{ 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, 1395{ 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10}, 1396{ 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12}, 1397{ 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12}, 1398{ 0x0003, 7} 1399}, 1400{ 1401{ 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5}, 1402{ 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7}, 1403{ 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8}, 1404{ 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9}, 1405{ 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10}, 1406{ 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11}, 1407{ 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11}, 1408{ 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12}, 1409{ 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12}, 1410{ 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7}, 1411{ 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10}, 1412{ 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12}, 1413{ 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7}, 1414{ 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12}, 1415{ 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10}, 1416{ 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10}, 1417{ 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11}, 1418{ 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13}, 1419{ 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13}, 1420{ 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11}, 1421{ 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13}, 1422{ 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11}, 1423{ 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12}, 1424{ 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13}, 1425{ 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14}, 1426{ 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16}, 1427{ 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13}, 1428{ 0x007A, 7} 1429}, 1430{ 1431{ 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7}, 1432{ 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9}, 1433{ 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11}, 1434{ 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12}, 1435{ 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13}, 1436{ 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8}, 1437{ 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12}, 1438{ 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8}, 1439{ 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5}, 1440{ 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5}, 1441{ 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10}, 1442{ 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14}, 1443{ 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15}, 1444{ 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9}, 1445{ 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10}, 1446{ 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11}, 1447{ 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12}, 1448{ 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13}, 1449{ 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6}, 1450{ 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7}, 1451{ 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13}, 1452{ 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15}, 1453{ 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15}, 1454{ 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17}, 1455{ 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20}, 1456{ 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20}, 1457{ 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21}, 1458{ 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22}, 1459{ 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13}, 1460{ 0x0073, 7} 1461} 1462}; 1463 1464static const uint16_t vlc_offs[] = { 1465 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436, 1466 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342, 1467 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522, 1468 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980, 1469 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866, 1470 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186, 1471 31714, 31746, 31778, 32306, 32340, 32372 1472}; 1473 1474/** 1475 * Init VC-1 specific tables and VC1Context members 1476 * @param v The VC1Context to initialize 1477 * @return Status 1478 */ 1479int ff_vc1_init_common(VC1Context *v) 1480{ 1481 static int done = 0; 1482 int i = 0; 1483 static VLC_TYPE vlc_table[32372][2]; 1484 1485 v->hrd_rate = v->hrd_buffer = NULL; 1486 1487 /* VLC tables */ 1488 if (!done) { 1489 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23, 1490 ff_vc1_bfraction_bits, 1, 1, 1491 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS); 1492 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4, 1493 ff_vc1_norm2_bits, 1, 1, 1494 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS); 1495 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64, 1496 ff_vc1_norm6_bits, 1, 1, 1497 ff_vc1_norm6_codes, 2, 2, 556); 1498 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7, 1499 ff_vc1_imode_bits, 1, 1, 1500 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS); 1501 for (i = 0; i < 3; i++) { 1502 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]]; 1503 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0]; 1504 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16, 1505 ff_vc1_ttmb_bits[i], 1, 1, 1506 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 1507 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]]; 1508 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1]; 1509 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8, 1510 ff_vc1_ttblk_bits[i], 1, 1, 1511 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC); 1512 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]]; 1513 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2]; 1514 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15, 1515 ff_vc1_subblkpat_bits[i], 1, 1, 1516 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC); 1517 } 1518 for (i = 0; i < 4; i++) { 1519 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]]; 1520 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9]; 1521 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16, 1522 ff_vc1_4mv_block_pattern_bits[i], 1, 1, 1523 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC); 1524 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]]; 1525 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10]; 1526 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64, 1527 ff_vc1_cbpcy_p_bits[i], 1, 1, 1528 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 1529 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]]; 1530 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11]; 1531 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73, 1532 ff_vc1_mv_diff_bits[i], 1, 1, 1533 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 1534 } 1535 for (i = 0; i < 8; i++) { 1536 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]]; 1537 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21]; 1538 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i], 1539 &vc1_ac_tables[i][0][1], 8, 4, 1540 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC); 1541 /* initialize interlaced MVDATA tables (2-Ref) */ 1542 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]]; 1543 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22]; 1544 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126, 1545 ff_vc1_2ref_mvdata_bits[i], 1, 1, 1546 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC); 1547 } 1548 for (i = 0; i < 4; i++) { 1549 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */ 1550 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]]; 1551 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37]; 1552 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15, 1553 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1, 1554 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 1555 /* initialize NON-4MV MBMODE VLC tables for the same */ 1556 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]]; 1557 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38]; 1558 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9, 1559 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1, 1560 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC); 1561 /* initialize interlaced MVDATA tables (1-Ref) */ 1562 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]]; 1563 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39]; 1564 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72, 1565 ff_vc1_1ref_mvdata_bits[i], 1, 1, 1566 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC); 1567 } 1568 for (i = 0; i < 4; i++) { 1569 /* Initialize 2MV Block pattern VLC tables */ 1570 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]]; 1571 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49]; 1572 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4, 1573 ff_vc1_2mv_block_pattern_bits[i], 1, 1, 1574 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC); 1575 } 1576 for (i = 0; i < 8; i++) { 1577 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */ 1578 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]]; 1579 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53]; 1580 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63, 1581 ff_vc1_icbpcy_p_bits[i], 1, 1, 1582 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC); 1583 /* Initialize interlaced field picture MBMODE VLC tables */ 1584 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]]; 1585 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54]; 1586 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8, 1587 ff_vc1_if_mmv_mbmode_bits[i], 1, 1, 1588 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC); 1589 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]]; 1590 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55]; 1591 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6, 1592 ff_vc1_if_1mv_mbmode_bits[i], 1, 1, 1593 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC); 1594 } 1595 done = 1; 1596 } 1597 1598 /* Other defaults */ 1599 v->pq = -1; 1600 v->mvrange = 0; /* 7.1.1.18, p80 */ 1601 1602 return 0; 1603} 1604