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