00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00030 #include "internal.h"
00031 #include "dsputil.h"
00032 #include "avcodec.h"
00033 #include "mpegvideo.h"
00034 #include "vc1.h"
00035 #include "vc1data.h"
00036 #include "msmpeg4data.h"
00037 #include "unary.h"
00038 #include "simple_idct.h"
00039
00040 #undef NDEBUG
00041 #include <assert.h>
00042
00043
00054 enum Imode {
00055 IMODE_RAW,
00056 IMODE_NORM2,
00057 IMODE_DIFF2,
00058 IMODE_NORM6,
00059 IMODE_DIFF6,
00060 IMODE_ROWSKIP,
00061 IMODE_COLSKIP
00062 };
00064
00071 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
00072 GetBitContext *gb)
00073 {
00074 int x, y;
00075
00076 for (y = 0; y < height; y++) {
00077 if (!get_bits1(gb))
00078 memset(plane, 0, width);
00079 else
00080 for (x = 0; x < width; x++)
00081 plane[x] = get_bits1(gb);
00082 plane += stride;
00083 }
00084 }
00085
00093 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
00094 GetBitContext *gb)
00095 {
00096 int x, y;
00097
00098 for (x = 0; x < width; x++) {
00099 if (!get_bits1(gb))
00100 for (y = 0; y < height; y++)
00101 plane[y*stride] = 0;
00102 else
00103 for (y = 0; y < height; y++)
00104 plane[y*stride] = get_bits1(gb);
00105 plane ++;
00106 }
00107 }
00108
00116 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
00117 {
00118 GetBitContext *gb = &v->s.gb;
00119
00120 int imode, x, y, code, offset;
00121 uint8_t invert, *planep = data;
00122 int width, height, stride;
00123
00124 width = v->s.mb_width;
00125 height = v->s.mb_height >> v->field_mode;
00126 stride = v->s.mb_stride;
00127 invert = get_bits1(gb);
00128 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
00129
00130 *raw_flag = 0;
00131 switch (imode) {
00132 case IMODE_RAW:
00133
00134 *raw_flag = 1;
00135 return invert;
00136 case IMODE_DIFF2:
00137 case IMODE_NORM2:
00138 if ((height * width) & 1) {
00139 *planep++ = get_bits1(gb);
00140 offset = 1;
00141 }
00142 else
00143 offset = 0;
00144
00145 for (y = offset; y < height * width; y += 2) {
00146 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
00147 *planep++ = code & 1;
00148 offset++;
00149 if (offset == width) {
00150 offset = 0;
00151 planep += stride - width;
00152 }
00153 *planep++ = code >> 1;
00154 offset++;
00155 if (offset == width) {
00156 offset = 0;
00157 planep += stride - width;
00158 }
00159 }
00160 break;
00161 case IMODE_DIFF6:
00162 case IMODE_NORM6:
00163 if (!(height % 3) && (width % 3)) {
00164 for (y = 0; y < height; y += 3) {
00165 for (x = width & 1; x < width; x += 2) {
00166 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
00167 if (code < 0) {
00168 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
00169 return -1;
00170 }
00171 planep[x + 0] = (code >> 0) & 1;
00172 planep[x + 1] = (code >> 1) & 1;
00173 planep[x + 0 + stride] = (code >> 2) & 1;
00174 planep[x + 1 + stride] = (code >> 3) & 1;
00175 planep[x + 0 + stride * 2] = (code >> 4) & 1;
00176 planep[x + 1 + stride * 2] = (code >> 5) & 1;
00177 }
00178 planep += stride * 3;
00179 }
00180 if (width & 1)
00181 decode_colskip(data, 1, height, stride, &v->s.gb);
00182 } else {
00183 planep += (height & 1) * stride;
00184 for (y = height & 1; y < height; y += 2) {
00185 for (x = width % 3; x < width; x += 3) {
00186 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
00187 if (code < 0) {
00188 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
00189 return -1;
00190 }
00191 planep[x + 0] = (code >> 0) & 1;
00192 planep[x + 1] = (code >> 1) & 1;
00193 planep[x + 2] = (code >> 2) & 1;
00194 planep[x + 0 + stride] = (code >> 3) & 1;
00195 planep[x + 1 + stride] = (code >> 4) & 1;
00196 planep[x + 2 + stride] = (code >> 5) & 1;
00197 }
00198 planep += stride * 2;
00199 }
00200 x = width % 3;
00201 if (x)
00202 decode_colskip(data, x, height, stride, &v->s.gb);
00203 if (height & 1)
00204 decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
00205 }
00206 break;
00207 case IMODE_ROWSKIP:
00208 decode_rowskip(data, width, height, stride, &v->s.gb);
00209 break;
00210 case IMODE_COLSKIP:
00211 decode_colskip(data, width, height, stride, &v->s.gb);
00212 break;
00213 default:
00214 break;
00215 }
00216
00217
00218 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
00219 planep = data;
00220 planep[0] ^= invert;
00221 for (x = 1; x < width; x++)
00222 planep[x] ^= planep[x-1];
00223 for (y = 1; y < height; y++) {
00224 planep += stride;
00225 planep[0] ^= planep[-stride];
00226 for (x = 1; x < width; x++) {
00227 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
00228 else planep[x] ^= planep[x-1];
00229 }
00230 }
00231 } else if (invert) {
00232 planep = data;
00233 for (x = 0; x < stride * height; x++)
00234 planep[x] = !planep[x];
00235 }
00236 return (imode << 1) + invert;
00237 }
00238
00240
00241
00245 static int vop_dquant_decoding(VC1Context *v)
00246 {
00247 GetBitContext *gb = &v->s.gb;
00248 int pqdiff;
00249
00250
00251 if (v->dquant == 2) {
00252 pqdiff = get_bits(gb, 3);
00253 if (pqdiff == 7)
00254 v->altpq = get_bits(gb, 5);
00255 else
00256 v->altpq = v->pq + pqdiff + 1;
00257 } else {
00258 v->dquantfrm = get_bits1(gb);
00259 if (v->dquantfrm) {
00260 v->dqprofile = get_bits(gb, 2);
00261 switch (v->dqprofile) {
00262 case DQPROFILE_SINGLE_EDGE:
00263 case DQPROFILE_DOUBLE_EDGES:
00264 v->dqsbedge = get_bits(gb, 2);
00265 break;
00266 case DQPROFILE_ALL_MBS:
00267 v->dqbilevel = get_bits1(gb);
00268 if (!v->dqbilevel)
00269 v->halfpq = 0;
00270 default:
00271 break;
00272 }
00273 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
00274 pqdiff = get_bits(gb, 3);
00275 if (pqdiff == 7)
00276 v->altpq = get_bits(gb, 5);
00277 else
00278 v->altpq = v->pq + pqdiff + 1;
00279 }
00280 }
00281 }
00282 return 0;
00283 }
00284
00285 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
00286
00294 int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
00295 {
00296 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
00297 v->profile = get_bits(gb, 2);
00298 if (v->profile == PROFILE_COMPLEX) {
00299 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
00300 }
00301
00302 if (v->profile == PROFILE_ADVANCED) {
00303 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
00304 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
00305 return decode_sequence_header_adv(v, gb);
00306 } else {
00307 v->zz_8x4 = wmv2_scantableA;
00308 v->zz_4x8 = wmv2_scantableB;
00309 v->res_y411 = get_bits1(gb);
00310 v->res_sprite = get_bits1(gb);
00311 if (v->res_y411) {
00312 av_log(avctx, AV_LOG_ERROR,
00313 "Old interlaced mode is not supported\n");
00314 return -1;
00315 }
00316 }
00317
00318
00319 v->frmrtq_postproc = get_bits(gb, 3);
00320
00321 v->bitrtq_postproc = get_bits(gb, 5);
00322 v->s.loop_filter = get_bits1(gb);
00323 if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
00324 av_log(avctx, AV_LOG_ERROR,
00325 "LOOPFILTER shall not be enabled in Simple Profile\n");
00326 }
00327 if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
00328 v->s.loop_filter = 0;
00329
00330 v->res_x8 = get_bits1(gb);
00331 v->multires = get_bits1(gb);
00332 v->res_fasttx = get_bits1(gb);
00333 if (!v->res_fasttx) {
00334 v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;
00335 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
00336 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
00337 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
00338 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
00339 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
00340 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
00341 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
00342 }
00343
00344 v->fastuvmc = get_bits1(gb);
00345 if (!v->profile && !v->fastuvmc) {
00346 av_log(avctx, AV_LOG_ERROR,
00347 "FASTUVMC unavailable in Simple Profile\n");
00348 return -1;
00349 }
00350 v->extended_mv = get_bits1(gb);
00351 if (!v->profile && v->extended_mv)
00352 {
00353 av_log(avctx, AV_LOG_ERROR,
00354 "Extended MVs unavailable in Simple Profile\n");
00355 return -1;
00356 }
00357 v->dquant = get_bits(gb, 2);
00358 v->vstransform = get_bits1(gb);
00359
00360 v->res_transtab = get_bits1(gb);
00361 if (v->res_transtab)
00362 {
00363 av_log(avctx, AV_LOG_ERROR,
00364 "1 for reserved RES_TRANSTAB is forbidden\n");
00365 return -1;
00366 }
00367
00368 v->overlap = get_bits1(gb);
00369
00370 v->s.resync_marker = get_bits1(gb);
00371 v->rangered = get_bits1(gb);
00372 if (v->rangered && v->profile == PROFILE_SIMPLE) {
00373 av_log(avctx, AV_LOG_INFO,
00374 "RANGERED should be set to 0 in Simple Profile\n");
00375 }
00376
00377 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3);
00378 v->quantizer_mode = get_bits(gb, 2);
00379
00380 v->finterpflag = get_bits1(gb);
00381
00382 if (v->res_sprite) {
00383 v->s.avctx->width = v->s.avctx->coded_width = get_bits(gb, 11);
00384 v->s.avctx->height = v->s.avctx->coded_height = get_bits(gb, 11);
00385 skip_bits(gb, 5);
00386 v->res_x8 = get_bits1(gb);
00387 if (get_bits1(gb)) {
00388 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
00389 return -1;
00390 }
00391 skip_bits(gb, 3);
00392 v->res_rtm_flag = 0;
00393 } else {
00394 v->res_rtm_flag = get_bits1(gb);
00395 }
00396 if (!v->res_rtm_flag) {
00397
00398
00399 av_log(avctx, AV_LOG_ERROR,
00400 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
00401
00402 }
00403
00404 if (!v->res_fasttx)
00405 skip_bits(gb, 16);
00406 av_log(avctx, AV_LOG_DEBUG,
00407 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
00408 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
00409 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
00410 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
00411 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
00412 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
00413 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
00414 v->dquant, v->quantizer_mode, avctx->max_b_frames);
00415 return 0;
00416 }
00417
00418 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
00419 {
00420 v->res_rtm_flag = 1;
00421 v->level = get_bits(gb, 3);
00422 if (v->level >= 5) {
00423 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
00424 }
00425 v->chromaformat = get_bits(gb, 2);
00426 if (v->chromaformat != 1) {
00427 av_log(v->s.avctx, AV_LOG_ERROR,
00428 "Only 4:2:0 chroma format supported\n");
00429 return -1;
00430 }
00431
00432
00433 v->frmrtq_postproc = get_bits(gb, 3);
00434
00435 v->bitrtq_postproc = get_bits(gb, 5);
00436 v->postprocflag = get_bits1(gb);
00437
00438 v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
00439 v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
00440 v->s.avctx->width = v->s.avctx->coded_width;
00441 v->s.avctx->height = v->s.avctx->coded_height;
00442 v->broadcast = get_bits1(gb);
00443 v->interlace = get_bits1(gb);
00444 v->tfcntrflag = get_bits1(gb);
00445 v->finterpflag = get_bits1(gb);
00446 skip_bits1(gb);
00447
00448 av_log(v->s.avctx, AV_LOG_DEBUG,
00449 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
00450 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
00451 "TFCTRflag=%i, FINTERPflag=%i\n",
00452 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
00453 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
00454 v->tfcntrflag, v->finterpflag);
00455
00456 v->psf = get_bits1(gb);
00457 if (v->psf) {
00458 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
00459 return -1;
00460 }
00461 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
00462 if (get_bits1(gb)) {
00463 int w, h, ar = 0;
00464 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
00465 w = get_bits(gb, 14) + 1;
00466 h = get_bits(gb, 14) + 1;
00467 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
00468 if (get_bits1(gb))
00469 ar = get_bits(gb, 4);
00470 if (ar && ar < 14) {
00471 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
00472 } else if (ar == 15) {
00473 w = get_bits(gb, 8) + 1;
00474 h = get_bits(gb, 8) + 1;
00475 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
00476 } else {
00477 av_reduce(&v->s.avctx->sample_aspect_ratio.num,
00478 &v->s.avctx->sample_aspect_ratio.den,
00479 v->s.avctx->height * w,
00480 v->s.avctx->width * h,
00481 1 << 30);
00482 }
00483 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
00484 v->s.avctx->sample_aspect_ratio.num,
00485 v->s.avctx->sample_aspect_ratio.den);
00486
00487 if (get_bits1(gb)) {
00488 if (get_bits1(gb)) {
00489 v->s.avctx->time_base.num = 32;
00490 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
00491 } else {
00492 int nr, dr;
00493 nr = get_bits(gb, 8);
00494 dr = get_bits(gb, 4);
00495 if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
00496 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
00497 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
00498 }
00499 }
00500 if (v->broadcast) {
00501 v->s.avctx->time_base.den *= 2;
00502 v->s.avctx->ticks_per_frame = 2;
00503 }
00504 }
00505
00506 if (get_bits1(gb)) {
00507 v->color_prim = get_bits(gb, 8);
00508 v->transfer_char = get_bits(gb, 8);
00509 v->matrix_coef = get_bits(gb, 8);
00510 }
00511 }
00512
00513 v->hrd_param_flag = get_bits1(gb);
00514 if (v->hrd_param_flag) {
00515 int i;
00516 v->hrd_num_leaky_buckets = get_bits(gb, 5);
00517 skip_bits(gb, 4);
00518 skip_bits(gb, 4);
00519 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
00520 skip_bits(gb, 16);
00521 skip_bits(gb, 16);
00522 }
00523 }
00524 return 0;
00525 }
00526
00527 int vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
00528 {
00529 int i;
00530
00531 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
00532 v->broken_link = get_bits1(gb);
00533 v->closed_entry = get_bits1(gb);
00534 v->panscanflag = get_bits1(gb);
00535 v->refdist_flag = get_bits1(gb);
00536 v->s.loop_filter = get_bits1(gb);
00537 v->fastuvmc = get_bits1(gb);
00538 v->extended_mv = get_bits1(gb);
00539 v->dquant = get_bits(gb, 2);
00540 v->vstransform = get_bits1(gb);
00541 v->overlap = get_bits1(gb);
00542 v->quantizer_mode = get_bits(gb, 2);
00543
00544 if (v->hrd_param_flag) {
00545 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
00546 skip_bits(gb, 8);
00547 }
00548 }
00549
00550 if (get_bits1(gb)) {
00551 avctx->width = avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
00552 avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
00553 }
00554 if (v->extended_mv)
00555 v->extended_dmv = get_bits1(gb);
00556 if ((v->range_mapy_flag = get_bits1(gb))) {
00557 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
00558 v->range_mapy = get_bits(gb, 3);
00559 }
00560 if ((v->range_mapuv_flag = get_bits1(gb))) {
00561 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
00562 v->range_mapuv = get_bits(gb, 3);
00563 }
00564
00565 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
00566 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
00567 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
00568 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
00569 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
00570 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
00571
00572 return 0;
00573 }
00574
00575 int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
00576 {
00577 int pqindex, lowquant, status;
00578
00579 if (v->finterpflag)
00580 v->interpfrm = get_bits1(gb);
00581 skip_bits(gb, 2);
00582 v->rangeredfrm = 0;
00583 if (v->rangered)
00584 v->rangeredfrm = get_bits1(gb);
00585 v->s.pict_type = get_bits1(gb);
00586 if (v->s.avctx->max_b_frames) {
00587 if (!v->s.pict_type) {
00588 if (get_bits1(gb))
00589 v->s.pict_type = AV_PICTURE_TYPE_I;
00590 else
00591 v->s.pict_type = AV_PICTURE_TYPE_B;
00592 } else
00593 v->s.pict_type = AV_PICTURE_TYPE_P;
00594 } else
00595 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00596
00597 v->bi_type = 0;
00598 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
00599 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00600 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00601 if (v->bfraction == 0) {
00602 v->s.pict_type = AV_PICTURE_TYPE_BI;
00603 }
00604 }
00605 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
00606 skip_bits(gb, 7);
00607
00608 if (v->parse_only)
00609 return 0;
00610
00611
00612 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
00613 v->rnd = 1;
00614 if (v->s.pict_type == AV_PICTURE_TYPE_P)
00615 v->rnd ^= 1;
00616
00617
00618 pqindex = get_bits(gb, 5);
00619 if (!pqindex)
00620 return -1;
00621 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00622 v->pq = ff_vc1_pquant_table[0][pqindex];
00623 else
00624 v->pq = ff_vc1_pquant_table[1][pqindex];
00625
00626 v->pquantizer = 1;
00627 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00628 v->pquantizer = pqindex < 9;
00629 if (v->quantizer_mode == QUANT_NON_UNIFORM)
00630 v->pquantizer = 0;
00631 v->pqindex = pqindex;
00632 if (pqindex < 9)
00633 v->halfpq = get_bits1(gb);
00634 else
00635 v->halfpq = 0;
00636 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
00637 v->pquantizer = get_bits1(gb);
00638 v->dquantfrm = 0;
00639 if (v->extended_mv == 1)
00640 v->mvrange = get_unary(gb, 0, 3);
00641 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
00642 v->k_y = v->mvrange + 8;
00643 v->range_x = 1 << (v->k_x - 1);
00644 v->range_y = 1 << (v->k_y - 1);
00645 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
00646 v->respic = get_bits(gb, 2);
00647
00648 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
00649 v->x8_type = get_bits1(gb);
00650 } else
00651 v->x8_type = 0;
00652
00653
00654
00655 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
00656 v->use_ic = 0;
00657
00658 switch (v->s.pict_type) {
00659 case AV_PICTURE_TYPE_P:
00660 if (v->pq < 5) v->tt_index = 0;
00661 else if (v->pq < 13) v->tt_index = 1;
00662 else v->tt_index = 2;
00663
00664 lowquant = (v->pq > 12) ? 0 : 1;
00665 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
00666 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00667 int scale, shift, i;
00668 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
00669 v->lumscale = get_bits(gb, 6);
00670 v->lumshift = get_bits(gb, 6);
00671 v->use_ic = 1;
00672
00673 if (!v->lumscale) {
00674 scale = -64;
00675 shift = (255 - v->lumshift * 2) << 6;
00676 if (v->lumshift > 31)
00677 shift += 128 << 6;
00678 } else {
00679 scale = v->lumscale + 32;
00680 if (v->lumshift > 31)
00681 shift = (v->lumshift - 64) << 6;
00682 else
00683 shift = v->lumshift << 6;
00684 }
00685 for (i = 0; i < 256; i++) {
00686 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
00687 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
00688 }
00689 }
00690 v->qs_last = v->s.quarter_sample;
00691 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
00692 v->s.quarter_sample = 0;
00693 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00694 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
00695 v->s.quarter_sample = 0;
00696 else
00697 v->s.quarter_sample = 1;
00698 } else
00699 v->s.quarter_sample = 1;
00700 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));
00701
00702 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
00703 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
00704 v->mv_mode == MV_PMODE_MIXED_MV) {
00705 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
00706 if (status < 0)
00707 return -1;
00708 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
00709 "Imode: %i, Invert: %i\n", status>>1, status&1);
00710 } else {
00711 v->mv_type_is_raw = 0;
00712 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
00713 }
00714 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
00715 if (status < 0)
00716 return -1;
00717 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
00718 "Imode: %i, Invert: %i\n", status>>1, status&1);
00719
00720
00721 v->s.mv_table_index = get_bits(gb, 2);
00722 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
00723
00724 if (v->dquant) {
00725 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
00726 vop_dquant_decoding(v);
00727 }
00728
00729 v->ttfrm = 0;
00730 if (v->vstransform) {
00731 v->ttmbf = get_bits1(gb);
00732 if (v->ttmbf) {
00733 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
00734 }
00735 } else {
00736 v->ttmbf = 1;
00737 v->ttfrm = TT_8X8;
00738 }
00739 break;
00740 case AV_PICTURE_TYPE_B:
00741 if (v->pq < 5) v->tt_index = 0;
00742 else if (v->pq < 13) v->tt_index = 1;
00743 else v->tt_index = 2;
00744
00745 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
00746 v->qs_last = v->s.quarter_sample;
00747 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
00748 v->s.mspel = v->s.quarter_sample;
00749
00750 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
00751 if (status < 0)
00752 return -1;
00753 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
00754 "Imode: %i, Invert: %i\n", status>>1, status&1);
00755 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
00756 if (status < 0)
00757 return -1;
00758 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
00759 "Imode: %i, Invert: %i\n", status>>1, status&1);
00760
00761 v->s.mv_table_index = get_bits(gb, 2);
00762 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
00763
00764 if (v->dquant) {
00765 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
00766 vop_dquant_decoding(v);
00767 }
00768
00769 v->ttfrm = 0;
00770 if (v->vstransform) {
00771 v->ttmbf = get_bits1(gb);
00772 if (v->ttmbf) {
00773 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
00774 }
00775 } else {
00776 v->ttmbf = 1;
00777 v->ttfrm = TT_8X8;
00778 }
00779 break;
00780 }
00781
00782 if (!v->x8_type) {
00783
00784 v->c_ac_table_index = decode012(gb);
00785 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
00786 v->y_ac_table_index = decode012(gb);
00787 }
00788
00789 v->s.dc_table_index = get_bits1(gb);
00790 }
00791
00792 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
00793 v->s.pict_type = AV_PICTURE_TYPE_B;
00794 v->bi_type = 1;
00795 }
00796 return 0;
00797 }
00798
00799
00800 #define INIT_LUT(lumscale, lumshift, luty, lutuv) \
00801 if (!lumscale) { \
00802 scale = -64; \
00803 shift = (255 - lumshift * 2) << 6; \
00804 if (lumshift > 31) \
00805 shift += 128 << 6; \
00806 } else { \
00807 scale = lumscale + 32; \
00808 if (lumshift > 31) \
00809 shift = (lumshift - 64) << 6; \
00810 else \
00811 shift = lumshift << 6; \
00812 } \
00813 for (i = 0; i < 256; i++) { \
00814 luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); \
00815 lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); \
00816 }
00817
00818 int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
00819 {
00820 int pqindex, lowquant;
00821 int status;
00822 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab;
00823 int scale, shift, i;
00824
00825 v->p_frame_skipped = 0;
00826 if (v->second_field) {
00827 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00828 if (v->fptype & 4)
00829 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
00830 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
00831 if (!v->pic_header_flag)
00832 goto parse_common_info;
00833 }
00834
00835 v->field_mode = 0;
00836 if (v->interlace) {
00837 v->fcm = decode012(gb);
00838 if (v->fcm) {
00839 if (v->fcm == ILACE_FIELD)
00840 v->field_mode = 1;
00841 if (!v->warn_interlaced++)
00842 av_log(v->s.avctx, AV_LOG_ERROR,
00843 "Interlaced frames/fields support is incomplete\n");
00844 }
00845 } else {
00846 v->fcm = PROGRESSIVE;
00847 }
00848
00849 if (v->field_mode) {
00850 v->fptype = get_bits(gb, 3);
00851 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00852 if (v->fptype & 4)
00853 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
00854 } else {
00855 switch (get_unary(gb, 0, 4)) {
00856 case 0:
00857 v->s.pict_type = AV_PICTURE_TYPE_P;
00858 break;
00859 case 1:
00860 v->s.pict_type = AV_PICTURE_TYPE_B;
00861 break;
00862 case 2:
00863 v->s.pict_type = AV_PICTURE_TYPE_I;
00864 break;
00865 case 3:
00866 v->s.pict_type = AV_PICTURE_TYPE_BI;
00867 break;
00868 case 4:
00869 v->s.pict_type = AV_PICTURE_TYPE_P;
00870 v->p_frame_skipped = 1;
00871 break;
00872 }
00873 }
00874 if (v->tfcntrflag)
00875 skip_bits(gb, 8);
00876 if (v->broadcast) {
00877 if (!v->interlace || v->psf) {
00878 v->rptfrm = get_bits(gb, 2);
00879 } else {
00880 v->tff = get_bits1(gb);
00881 v->rff = get_bits1(gb);
00882 }
00883 }
00884 if (v->panscanflag) {
00885 av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
00886
00887 }
00888 if (v->p_frame_skipped) {
00889 return 0;
00890 }
00891 v->rnd = get_bits1(gb);
00892 if (v->interlace)
00893 v->uvsamp = get_bits1(gb);
00894 if (v->field_mode) {
00895 if (!v->refdist_flag)
00896 v->refdist = 0;
00897 else {
00898 if ((v->s.pict_type != AV_PICTURE_TYPE_B)
00899 && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
00900 v->refdist = get_bits(gb, 2);
00901 if (v->refdist == 3)
00902 v->refdist += get_unary(gb, 0, 16);
00903 } else {
00904 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00905 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00906 v->frfd = (v->bfraction * v->refdist) >> 8;
00907 v->brfd = v->refdist - v->frfd - 1;
00908 if (v->brfd < 0)
00909 v->brfd = 0;
00910 }
00911 }
00912 goto parse_common_info;
00913 }
00914 if (v->finterpflag)
00915 v->interpfrm = get_bits1(gb);
00916 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
00917 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00918 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00919 if (v->bfraction == 0) {
00920 v->s.pict_type = AV_PICTURE_TYPE_BI;
00921 }
00922 }
00923
00924 parse_common_info:
00925 if (v->field_mode)
00926 v->cur_field_type = !(v->tff ^ v->second_field);
00927 pqindex = get_bits(gb, 5);
00928 if (!pqindex)
00929 return -1;
00930 v->pqindex = pqindex;
00931 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00932 v->pq = ff_vc1_pquant_table[0][pqindex];
00933 else
00934 v->pq = ff_vc1_pquant_table[1][pqindex];
00935
00936 v->pquantizer = 1;
00937 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00938 v->pquantizer = pqindex < 9;
00939 if (v->quantizer_mode == QUANT_NON_UNIFORM)
00940 v->pquantizer = 0;
00941 v->pqindex = pqindex;
00942 if (pqindex < 9)
00943 v->halfpq = get_bits1(gb);
00944 else
00945 v->halfpq = 0;
00946 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
00947 v->pquantizer = get_bits1(gb);
00948 if (v->postprocflag)
00949 v->postproc = get_bits(gb, 2);
00950
00951 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
00952 v->use_ic = 0;
00953
00954 if (v->parse_only)
00955 return 0;
00956
00957 switch (v->s.pict_type) {
00958 case AV_PICTURE_TYPE_I:
00959 case AV_PICTURE_TYPE_BI:
00960 if (v->fcm == ILACE_FRAME) {
00961 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
00962 if (status < 0)
00963 return -1;
00964 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
00965 "Imode: %i, Invert: %i\n", status>>1, status&1);
00966 }
00967 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
00968 if (status < 0)
00969 return -1;
00970 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
00971 "Imode: %i, Invert: %i\n", status>>1, status&1);
00972 v->condover = CONDOVER_NONE;
00973 if (v->overlap && v->pq <= 8) {
00974 v->condover = decode012(gb);
00975 if (v->condover == CONDOVER_SELECT) {
00976 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
00977 if (status < 0)
00978 return -1;
00979 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
00980 "Imode: %i, Invert: %i\n", status>>1, status&1);
00981 }
00982 }
00983 break;
00984 case AV_PICTURE_TYPE_P:
00985 if (v->field_mode) {
00986 v->numref = get_bits1(gb);
00987 if (!v->numref) {
00988 v->reffield = get_bits1(gb);
00989 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
00990 }
00991 }
00992 if (v->extended_mv)
00993 v->mvrange = get_unary(gb, 0, 3);
00994 else
00995 v->mvrange = 0;
00996 if (v->interlace) {
00997 if (v->extended_dmv)
00998 v->dmvrange = get_unary(gb, 0, 3);
00999 else
01000 v->dmvrange = 0;
01001 if (v->fcm == ILACE_FRAME) {
01002 v->fourmvswitch = get_bits1(gb);
01003 v->intcomp = get_bits1(gb);
01004 if (v->intcomp) {
01005 v->lumscale = get_bits(gb, 6);
01006 v->lumshift = get_bits(gb, 6);
01007 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
01008 }
01009 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01010 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
01011 "Imode: %i, Invert: %i\n", status>>1, status&1);
01012 mbmodetab = get_bits(gb, 2);
01013 if (v->fourmvswitch)
01014 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
01015 else
01016 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
01017 imvtab = get_bits(gb, 2);
01018 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
01019
01020 icbptab = get_bits(gb, 3);
01021 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01022 twomvbptab = get_bits(gb, 2);
01023 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
01024 if (v->fourmvswitch) {
01025 fourmvbptab = get_bits(gb, 2);
01026 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01027 }
01028 }
01029 }
01030 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
01031 v->k_y = v->mvrange + 8;
01032 v->range_x = 1 << (v->k_x - 1);
01033 v->range_y = 1 << (v->k_y - 1);
01034
01035 if (v->pq < 5)
01036 v->tt_index = 0;
01037 else if (v->pq < 13)
01038 v->tt_index = 1;
01039 else
01040 v->tt_index = 2;
01041 if (v->fcm != ILACE_FRAME) {
01042 int mvmode;
01043 mvmode = get_unary(gb, 1, 4);
01044 lowquant = (v->pq > 12) ? 0 : 1;
01045 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
01046 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01047 int mvmode2;
01048 mvmode2 = get_unary(gb, 1, 3);
01049 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
01050 if (v->field_mode)
01051 v->intcompfield = decode210(gb);
01052 v->lumscale = get_bits(gb, 6);
01053 v->lumshift = get_bits(gb, 6);
01054 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
01055 if ((v->field_mode) && !v->intcompfield) {
01056 v->lumscale2 = get_bits(gb, 6);
01057 v->lumshift2 = get_bits(gb, 6);
01058 INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
01059 }
01060 v->use_ic = 1;
01061 }
01062 v->qs_last = v->s.quarter_sample;
01063 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
01064 v->s.quarter_sample = 0;
01065 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01066 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
01067 v->s.quarter_sample = 0;
01068 else
01069 v->s.quarter_sample = 1;
01070 } else
01071 v->s.quarter_sample = 1;
01072 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
01073 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
01074 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
01075 }
01076 if (v->fcm == PROGRESSIVE) {
01077 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01078 v->mv_mode2 == MV_PMODE_MIXED_MV)
01079 || v->mv_mode == MV_PMODE_MIXED_MV) {
01080 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
01081 if (status < 0)
01082 return -1;
01083 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
01084 "Imode: %i, Invert: %i\n", status>>1, status&1);
01085 } else {
01086 v->mv_type_is_raw = 0;
01087 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
01088 }
01089 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01090 if (status < 0)
01091 return -1;
01092 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01093 "Imode: %i, Invert: %i\n", status>>1, status&1);
01094
01095
01096 v->s.mv_table_index = get_bits(gb, 2);
01097 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01098 } else if (v->fcm == ILACE_FRAME) {
01099 v->qs_last = v->s.quarter_sample;
01100 v->s.quarter_sample = 1;
01101 v->s.mspel = 1;
01102 } else {
01103 mbmodetab = get_bits(gb, 3);
01104 imvtab = get_bits(gb, 2 + v->numref);
01105 if (!v->numref)
01106 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
01107 else
01108 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
01109 icbptab = get_bits(gb, 3);
01110 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01111 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01112 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
01113 fourmvbptab = get_bits(gb, 2);
01114 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01115 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
01116 } else {
01117 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
01118 }
01119 }
01120 if (v->dquant) {
01121 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01122 vop_dquant_decoding(v);
01123 }
01124
01125 v->ttfrm = 0;
01126 if (v->vstransform) {
01127 v->ttmbf = get_bits1(gb);
01128 if (v->ttmbf) {
01129 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01130 }
01131 } else {
01132 v->ttmbf = 1;
01133 v->ttfrm = TT_8X8;
01134 }
01135 break;
01136 case AV_PICTURE_TYPE_B:
01137
01138 if (v->fcm == ILACE_FRAME)
01139 return -1;
01140 if (v->extended_mv)
01141 v->mvrange = get_unary(gb, 0, 3);
01142 else
01143 v->mvrange = 0;
01144 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
01145 v->k_y = v->mvrange + 8;
01146 v->range_x = 1 << (v->k_x - 1);
01147 v->range_y = 1 << (v->k_y - 1);
01148
01149 if (v->pq < 5)
01150 v->tt_index = 0;
01151 else if (v->pq < 13)
01152 v->tt_index = 1;
01153 else
01154 v->tt_index = 2;
01155
01156 if (v->field_mode) {
01157 int mvmode;
01158 if (v->extended_dmv)
01159 v->dmvrange = get_unary(gb, 0, 3);
01160 mvmode = get_unary(gb, 1, 3);
01161 lowquant = (v->pq > 12) ? 0 : 1;
01162 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
01163 v->qs_last = v->s.quarter_sample;
01164 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
01165 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
01166 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
01167 if (status < 0)
01168 return -1;
01169 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
01170 "Imode: %i, Invert: %i\n", status>>1, status&1);
01171 mbmodetab = get_bits(gb, 3);
01172 if (v->mv_mode == MV_PMODE_MIXED_MV)
01173 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
01174 else
01175 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
01176 imvtab = get_bits(gb, 3);
01177 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
01178 icbptab = get_bits(gb, 3);
01179 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01180 if (v->mv_mode == MV_PMODE_MIXED_MV) {
01181 fourmvbptab = get_bits(gb, 2);
01182 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01183 }
01184 v->numref = 1;
01185 } else {
01186 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
01187 v->qs_last = v->s.quarter_sample;
01188 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
01189 v->s.mspel = v->s.quarter_sample;
01190 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
01191 if (status < 0)
01192 return -1;
01193 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
01194 "Imode: %i, Invert: %i\n", status>>1, status&1);
01195 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01196 if (status < 0)
01197 return -1;
01198 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01199 "Imode: %i, Invert: %i\n", status>>1, status&1);
01200 v->s.mv_table_index = get_bits(gb, 2);
01201 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01202 }
01203
01204 if (v->dquant) {
01205 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01206 vop_dquant_decoding(v);
01207 }
01208
01209 v->ttfrm = 0;
01210 if (v->vstransform) {
01211 v->ttmbf = get_bits1(gb);
01212 if (v->ttmbf) {
01213 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01214 }
01215 } else {
01216 v->ttmbf = 1;
01217 v->ttfrm = TT_8X8;
01218 }
01219 break;
01220 }
01221
01222
01223 v->c_ac_table_index = decode012(gb);
01224 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
01225 v->y_ac_table_index = decode012(gb);
01226 }
01227
01228 v->s.dc_table_index = get_bits1(gb);
01229 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
01230 && v->dquant) {
01231 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01232 vop_dquant_decoding(v);
01233 }
01234
01235 v->bi_type = 0;
01236 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
01237 v->s.pict_type = AV_PICTURE_TYPE_B;
01238 v->bi_type = 1;
01239 }
01240 return 0;
01241 }
01242
01243 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
01244 {
01245 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
01246 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
01247 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
01248 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
01249 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
01250 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
01251 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
01252 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
01253 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
01254 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
01255 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
01256 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
01257 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
01258 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
01259 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
01260 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
01261 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
01262 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
01263 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
01264 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
01265 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
01266 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
01267 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
01268 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
01269 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
01270 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
01271 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
01272 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
01273 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
01274 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
01275 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
01276 },
01277 {
01278 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
01279 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
01280 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
01281 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
01282 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
01283 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
01284 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
01285 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
01286 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
01287 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
01288 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
01289 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
01290 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
01291 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
01292 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
01293 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
01294 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
01295 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
01296 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
01297 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
01298 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
01299 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
01300 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
01301 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
01302 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
01303 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
01304 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
01305 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
01306 { 0x0169, 9}
01307 },
01308 {
01309 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
01310 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
01311 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
01312 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
01313 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
01314 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
01315 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
01316 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
01317 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
01318 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
01319 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
01320 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
01321 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
01322 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
01323 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
01324 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
01325 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
01326 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
01327 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
01328 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
01329 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
01330 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
01331 { 0x0016, 7}
01332 },
01333 {
01334 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
01335 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
01336 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
01337 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
01338 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
01339 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
01340 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
01341 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
01342 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
01343 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
01344 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
01345 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
01346 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
01347 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
01348 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
01349 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
01350 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
01351 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
01352 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
01353 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
01354 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
01355 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
01356 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
01357 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
01358 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
01359 },
01360 {
01361 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
01362 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
01363 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
01364 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
01365 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
01366 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
01367 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
01368 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
01369 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
01370 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
01371 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
01372 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
01373 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
01374 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
01375 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
01376 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
01377 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
01378 { 0x0003, 7}
01379 },
01380 {
01381 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
01382 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
01383 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
01384 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
01385 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
01386 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
01387 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
01388 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
01389 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
01390 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
01391 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
01392 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
01393 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
01394 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
01395 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
01396 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
01397 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
01398 { 0x0003, 7}
01399 },
01400 {
01401 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
01402 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
01403 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
01404 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
01405 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
01406 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
01407 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
01408 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
01409 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
01410 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
01411 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
01412 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
01413 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
01414 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
01415 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
01416 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
01417 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
01418 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
01419 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
01420 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
01421 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
01422 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
01423 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
01424 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
01425 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
01426 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
01427 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
01428 { 0x007A, 7}
01429 },
01430 {
01431 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
01432 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
01433 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
01434 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
01435 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
01436 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
01437 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
01438 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
01439 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
01440 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
01441 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
01442 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
01443 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
01444 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
01445 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
01446 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
01447 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
01448 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
01449 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
01450 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
01451 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
01452 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
01453 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
01454 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
01455 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
01456 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
01457 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
01458 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
01459 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
01460 { 0x0073, 7}
01461 }
01462 };
01463
01464 static const uint16_t vlc_offs[] = {
01465 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
01466 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
01467 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
01468 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
01469 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
01470 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
01471 31714, 31746, 31778, 32306, 32340, 32372
01472 };
01473
01479 int ff_vc1_init_common(VC1Context *v)
01480 {
01481 static int done = 0;
01482 int i = 0;
01483 static VLC_TYPE vlc_table[32372][2];
01484
01485 v->hrd_rate = v->hrd_buffer = NULL;
01486
01487
01488 if (!done) {
01489 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
01490 ff_vc1_bfraction_bits, 1, 1,
01491 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
01492 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
01493 ff_vc1_norm2_bits, 1, 1,
01494 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
01495 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
01496 ff_vc1_norm6_bits, 1, 1,
01497 ff_vc1_norm6_codes, 2, 2, 556);
01498 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
01499 ff_vc1_imode_bits, 1, 1,
01500 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
01501 for (i = 0; i < 3; i++) {
01502 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
01503 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
01504 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
01505 ff_vc1_ttmb_bits[i], 1, 1,
01506 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01507 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
01508 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
01509 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
01510 ff_vc1_ttblk_bits[i], 1, 1,
01511 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01512 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
01513 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
01514 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
01515 ff_vc1_subblkpat_bits[i], 1, 1,
01516 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01517 }
01518 for (i = 0; i < 4; i++) {
01519 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
01520 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
01521 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
01522 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
01523 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01524 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
01525 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
01526 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
01527 ff_vc1_cbpcy_p_bits[i], 1, 1,
01528 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01529 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
01530 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
01531 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
01532 ff_vc1_mv_diff_bits[i], 1, 1,
01533 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01534 }
01535 for (i = 0; i < 8; i++) {
01536 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
01537 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
01538 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
01539 &vc1_ac_tables[i][0][1], 8, 4,
01540 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
01541
01542 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
01543 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
01544 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
01545 ff_vc1_2ref_mvdata_bits[i], 1, 1,
01546 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
01547 }
01548 for (i = 0; i < 4; i++) {
01549
01550 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
01551 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
01552 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
01553 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
01554 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01555
01556 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
01557 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
01558 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
01559 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
01560 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01561
01562 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
01563 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
01564 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
01565 ff_vc1_1ref_mvdata_bits[i], 1, 1,
01566 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
01567 }
01568 for (i = 0; i < 4; i++) {
01569
01570 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
01571 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
01572 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
01573 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
01574 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01575 }
01576 for (i = 0; i < 8; i++) {
01577
01578 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
01579 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
01580 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
01581 ff_vc1_icbpcy_p_bits[i], 1, 1,
01582 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01583
01584 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
01585 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
01586 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
01587 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
01588 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01589 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
01590 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
01591 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
01592 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
01593 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01594 }
01595 done = 1;
01596 }
01597
01598
01599 v->pq = -1;
01600 v->mvrange = 0;
01601
01602 return 0;
01603 }