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->numref = 0;
00826 v->p_frame_skipped = 0;
00827 if (v->second_field) {
00828 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00829 if (v->fptype & 4)
00830 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
00831 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
00832 if (!v->pic_header_flag)
00833 goto parse_common_info;
00834 }
00835
00836 v->field_mode = 0;
00837 if (v->interlace) {
00838 v->fcm = decode012(gb);
00839 if (v->fcm) {
00840 if (v->fcm == ILACE_FIELD)
00841 v->field_mode = 1;
00842 if (!v->warn_interlaced++)
00843 av_log(v->s.avctx, AV_LOG_ERROR,
00844 "Interlaced frames/fields support is incomplete\n");
00845 }
00846 } else {
00847 v->fcm = PROGRESSIVE;
00848 }
00849
00850 if (v->field_mode) {
00851 v->fptype = get_bits(gb, 3);
00852 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00853 if (v->fptype & 4)
00854 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
00855 } else {
00856 switch (get_unary(gb, 0, 4)) {
00857 case 0:
00858 v->s.pict_type = AV_PICTURE_TYPE_P;
00859 break;
00860 case 1:
00861 v->s.pict_type = AV_PICTURE_TYPE_B;
00862 break;
00863 case 2:
00864 v->s.pict_type = AV_PICTURE_TYPE_I;
00865 break;
00866 case 3:
00867 v->s.pict_type = AV_PICTURE_TYPE_BI;
00868 break;
00869 case 4:
00870 v->s.pict_type = AV_PICTURE_TYPE_P;
00871 v->p_frame_skipped = 1;
00872 break;
00873 }
00874 }
00875 if (v->tfcntrflag)
00876 skip_bits(gb, 8);
00877 if (v->broadcast) {
00878 if (!v->interlace || v->psf) {
00879 v->rptfrm = get_bits(gb, 2);
00880 } else {
00881 v->tff = get_bits1(gb);
00882 v->rff = get_bits1(gb);
00883 }
00884 }
00885 if (v->panscanflag) {
00886 av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
00887
00888 }
00889 if (v->p_frame_skipped) {
00890 return 0;
00891 }
00892 v->rnd = get_bits1(gb);
00893 if (v->interlace)
00894 v->uvsamp = get_bits1(gb);
00895 if (v->field_mode) {
00896 if (!v->refdist_flag)
00897 v->refdist = 0;
00898 else {
00899 if ((v->s.pict_type != AV_PICTURE_TYPE_B)
00900 && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
00901 v->refdist = get_bits(gb, 2);
00902 if (v->refdist == 3)
00903 v->refdist += get_unary(gb, 0, 16);
00904 } else {
00905 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00906 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00907 v->frfd = (v->bfraction * v->refdist) >> 8;
00908 v->brfd = v->refdist - v->frfd - 1;
00909 if (v->brfd < 0)
00910 v->brfd = 0;
00911 }
00912 }
00913 goto parse_common_info;
00914 }
00915 if (v->finterpflag)
00916 v->interpfrm = get_bits1(gb);
00917 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
00918 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00919 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00920 if (v->bfraction == 0) {
00921 v->s.pict_type = AV_PICTURE_TYPE_BI;
00922 }
00923 }
00924
00925 parse_common_info:
00926 if (v->field_mode)
00927 v->cur_field_type = !(v->tff ^ v->second_field);
00928 pqindex = get_bits(gb, 5);
00929 if (!pqindex)
00930 return -1;
00931 v->pqindex = pqindex;
00932 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00933 v->pq = ff_vc1_pquant_table[0][pqindex];
00934 else
00935 v->pq = ff_vc1_pquant_table[1][pqindex];
00936
00937 v->pquantizer = 1;
00938 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00939 v->pquantizer = pqindex < 9;
00940 if (v->quantizer_mode == QUANT_NON_UNIFORM)
00941 v->pquantizer = 0;
00942 v->pqindex = pqindex;
00943 if (pqindex < 9)
00944 v->halfpq = get_bits1(gb);
00945 else
00946 v->halfpq = 0;
00947 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
00948 v->pquantizer = get_bits1(gb);
00949 if (v->postprocflag)
00950 v->postproc = get_bits(gb, 2);
00951
00952 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
00953 v->use_ic = 0;
00954
00955 if (v->parse_only)
00956 return 0;
00957
00958 switch (v->s.pict_type) {
00959 case AV_PICTURE_TYPE_I:
00960 case AV_PICTURE_TYPE_BI:
00961 if (v->fcm == ILACE_FRAME) {
00962 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
00963 if (status < 0)
00964 return -1;
00965 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
00966 "Imode: %i, Invert: %i\n", status>>1, status&1);
00967 }
00968 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
00969 if (status < 0)
00970 return -1;
00971 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
00972 "Imode: %i, Invert: %i\n", status>>1, status&1);
00973 v->condover = CONDOVER_NONE;
00974 if (v->overlap && v->pq <= 8) {
00975 v->condover = decode012(gb);
00976 if (v->condover == CONDOVER_SELECT) {
00977 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
00978 if (status < 0)
00979 return -1;
00980 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
00981 "Imode: %i, Invert: %i\n", status>>1, status&1);
00982 }
00983 }
00984 break;
00985 case AV_PICTURE_TYPE_P:
00986 if (v->field_mode) {
00987 v->numref = get_bits1(gb);
00988 if (!v->numref) {
00989 v->reffield = get_bits1(gb);
00990 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
00991 }
00992 }
00993 if (v->extended_mv)
00994 v->mvrange = get_unary(gb, 0, 3);
00995 else
00996 v->mvrange = 0;
00997 if (v->interlace) {
00998 if (v->extended_dmv)
00999 v->dmvrange = get_unary(gb, 0, 3);
01000 else
01001 v->dmvrange = 0;
01002 if (v->fcm == ILACE_FRAME) {
01003 v->fourmvswitch = get_bits1(gb);
01004 v->intcomp = get_bits1(gb);
01005 if (v->intcomp) {
01006 v->lumscale = get_bits(gb, 6);
01007 v->lumshift = get_bits(gb, 6);
01008 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
01009 }
01010 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01011 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
01012 "Imode: %i, Invert: %i\n", status>>1, status&1);
01013 mbmodetab = get_bits(gb, 2);
01014 if (v->fourmvswitch)
01015 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
01016 else
01017 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
01018 imvtab = get_bits(gb, 2);
01019 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
01020
01021 icbptab = get_bits(gb, 3);
01022 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01023 twomvbptab = get_bits(gb, 2);
01024 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
01025 if (v->fourmvswitch) {
01026 fourmvbptab = get_bits(gb, 2);
01027 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01028 }
01029 }
01030 }
01031 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
01032 v->k_y = v->mvrange + 8;
01033 v->range_x = 1 << (v->k_x - 1);
01034 v->range_y = 1 << (v->k_y - 1);
01035
01036 if (v->pq < 5)
01037 v->tt_index = 0;
01038 else if (v->pq < 13)
01039 v->tt_index = 1;
01040 else
01041 v->tt_index = 2;
01042 if (v->fcm != ILACE_FRAME) {
01043 int mvmode;
01044 mvmode = get_unary(gb, 1, 4);
01045 lowquant = (v->pq > 12) ? 0 : 1;
01046 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
01047 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01048 int mvmode2;
01049 mvmode2 = get_unary(gb, 1, 3);
01050 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
01051 if (v->field_mode)
01052 v->intcompfield = decode210(gb);
01053 v->lumscale = get_bits(gb, 6);
01054 v->lumshift = get_bits(gb, 6);
01055 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
01056 if ((v->field_mode) && !v->intcompfield) {
01057 v->lumscale2 = get_bits(gb, 6);
01058 v->lumshift2 = get_bits(gb, 6);
01059 INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
01060 }
01061 v->use_ic = 1;
01062 }
01063 v->qs_last = v->s.quarter_sample;
01064 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
01065 v->s.quarter_sample = 0;
01066 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01067 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
01068 v->s.quarter_sample = 0;
01069 else
01070 v->s.quarter_sample = 1;
01071 } else
01072 v->s.quarter_sample = 1;
01073 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
01074 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
01075 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
01076 }
01077 if (v->fcm == PROGRESSIVE) {
01078 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01079 v->mv_mode2 == MV_PMODE_MIXED_MV)
01080 || v->mv_mode == MV_PMODE_MIXED_MV) {
01081 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
01082 if (status < 0)
01083 return -1;
01084 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
01085 "Imode: %i, Invert: %i\n", status>>1, status&1);
01086 } else {
01087 v->mv_type_is_raw = 0;
01088 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
01089 }
01090 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01091 if (status < 0)
01092 return -1;
01093 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01094 "Imode: %i, Invert: %i\n", status>>1, status&1);
01095
01096
01097 v->s.mv_table_index = get_bits(gb, 2);
01098 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01099 } else if (v->fcm == ILACE_FRAME) {
01100 v->qs_last = v->s.quarter_sample;
01101 v->s.quarter_sample = 1;
01102 v->s.mspel = 1;
01103 } else {
01104 mbmodetab = get_bits(gb, 3);
01105 imvtab = get_bits(gb, 2 + v->numref);
01106 if (!v->numref)
01107 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
01108 else
01109 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
01110 icbptab = get_bits(gb, 3);
01111 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01112 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01113 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
01114 fourmvbptab = get_bits(gb, 2);
01115 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01116 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
01117 } else {
01118 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
01119 }
01120 }
01121 if (v->dquant) {
01122 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01123 vop_dquant_decoding(v);
01124 }
01125
01126 v->ttfrm = 0;
01127 if (v->vstransform) {
01128 v->ttmbf = get_bits1(gb);
01129 if (v->ttmbf) {
01130 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01131 }
01132 } else {
01133 v->ttmbf = 1;
01134 v->ttfrm = TT_8X8;
01135 }
01136 break;
01137 case AV_PICTURE_TYPE_B:
01138
01139 if (v->fcm == ILACE_FRAME)
01140 return -1;
01141 if (v->extended_mv)
01142 v->mvrange = get_unary(gb, 0, 3);
01143 else
01144 v->mvrange = 0;
01145 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
01146 v->k_y = v->mvrange + 8;
01147 v->range_x = 1 << (v->k_x - 1);
01148 v->range_y = 1 << (v->k_y - 1);
01149
01150 if (v->pq < 5)
01151 v->tt_index = 0;
01152 else if (v->pq < 13)
01153 v->tt_index = 1;
01154 else
01155 v->tt_index = 2;
01156
01157 if (v->field_mode) {
01158 int mvmode;
01159 if (v->extended_dmv)
01160 v->dmvrange = get_unary(gb, 0, 3);
01161 mvmode = get_unary(gb, 1, 3);
01162 lowquant = (v->pq > 12) ? 0 : 1;
01163 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
01164 v->qs_last = v->s.quarter_sample;
01165 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
01166 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
01167 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
01168 if (status < 0)
01169 return -1;
01170 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
01171 "Imode: %i, Invert: %i\n", status>>1, status&1);
01172 mbmodetab = get_bits(gb, 3);
01173 if (v->mv_mode == MV_PMODE_MIXED_MV)
01174 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
01175 else
01176 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
01177 imvtab = get_bits(gb, 3);
01178 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
01179 icbptab = get_bits(gb, 3);
01180 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01181 if (v->mv_mode == MV_PMODE_MIXED_MV) {
01182 fourmvbptab = get_bits(gb, 2);
01183 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01184 }
01185 v->numref = 1;
01186 } else {
01187 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
01188 v->qs_last = v->s.quarter_sample;
01189 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
01190 v->s.mspel = v->s.quarter_sample;
01191 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
01192 if (status < 0)
01193 return -1;
01194 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
01195 "Imode: %i, Invert: %i\n", status>>1, status&1);
01196 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01197 if (status < 0)
01198 return -1;
01199 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01200 "Imode: %i, Invert: %i\n", status>>1, status&1);
01201 v->s.mv_table_index = get_bits(gb, 2);
01202 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01203 }
01204
01205 if (v->dquant) {
01206 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01207 vop_dquant_decoding(v);
01208 }
01209
01210 v->ttfrm = 0;
01211 if (v->vstransform) {
01212 v->ttmbf = get_bits1(gb);
01213 if (v->ttmbf) {
01214 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01215 }
01216 } else {
01217 v->ttmbf = 1;
01218 v->ttfrm = TT_8X8;
01219 }
01220 break;
01221 }
01222
01223
01224 v->c_ac_table_index = decode012(gb);
01225 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
01226 v->y_ac_table_index = decode012(gb);
01227 }
01228
01229 v->s.dc_table_index = get_bits1(gb);
01230 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
01231 && v->dquant) {
01232 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01233 vop_dquant_decoding(v);
01234 }
01235
01236 v->bi_type = 0;
01237 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
01238 v->s.pict_type = AV_PICTURE_TYPE_B;
01239 v->bi_type = 1;
01240 }
01241 return 0;
01242 }
01243
01244 static const uint32_t vc1_ac_tables[AC_MODES][186][2] = {
01245 {
01246 { 0x0001, 2}, { 0x0005, 3}, { 0x000D, 4}, { 0x0012, 5}, { 0x000E, 6}, { 0x0015, 7},
01247 { 0x0013, 8}, { 0x003F, 8}, { 0x004B, 9}, { 0x011F, 9}, { 0x00B8, 10}, { 0x03E3, 10},
01248 { 0x0172, 11}, { 0x024D, 12}, { 0x03DA, 12}, { 0x02DD, 13}, { 0x1F55, 13}, { 0x05B9, 14},
01249 { 0x3EAE, 14}, { 0x0000, 4}, { 0x0010, 5}, { 0x0008, 7}, { 0x0020, 8}, { 0x0029, 9},
01250 { 0x01F4, 9}, { 0x0233, 10}, { 0x01E0, 11}, { 0x012A, 12}, { 0x03DD, 12}, { 0x050A, 13},
01251 { 0x1F29, 13}, { 0x0A42, 14}, { 0x1272, 15}, { 0x1737, 15}, { 0x0003, 5}, { 0x0011, 7},
01252 { 0x00C4, 8}, { 0x004B, 10}, { 0x00B4, 11}, { 0x07D4, 11}, { 0x0345, 12}, { 0x02D7, 13},
01253 { 0x07BF, 13}, { 0x0938, 14}, { 0x0BBB, 14}, { 0x095E, 15}, { 0x0013, 5}, { 0x0078, 7},
01254 { 0x0069, 9}, { 0x0232, 10}, { 0x0461, 11}, { 0x03EC, 12}, { 0x0520, 13}, { 0x1F2A, 13},
01255 { 0x3E50, 14}, { 0x3E51, 14}, { 0x1486, 15}, { 0x000C, 6}, { 0x0024, 9}, { 0x0094, 11},
01256 { 0x08C0, 12}, { 0x0F09, 14}, { 0x1EF0, 15}, { 0x003D, 6}, { 0x0053, 9}, { 0x01A0, 11},
01257 { 0x02D6, 13}, { 0x0F08, 14}, { 0x0013, 7}, { 0x007C, 9}, { 0x07C1, 11}, { 0x04AC, 14},
01258 { 0x001B, 7}, { 0x00A0, 10}, { 0x0344, 12}, { 0x0F79, 14}, { 0x0079, 7}, { 0x03E1, 10},
01259 { 0x02D4, 13}, { 0x2306, 14}, { 0x0021, 8}, { 0x023C, 10}, { 0x0FAE, 12}, { 0x23DE, 14},
01260 { 0x0035, 8}, { 0x0175, 11}, { 0x07B3, 13}, { 0x00C5, 8}, { 0x0174, 11}, { 0x0785, 13},
01261 { 0x0048, 9}, { 0x01A3, 11}, { 0x049E, 13}, { 0x002C, 9}, { 0x00FA, 10}, { 0x07D6, 11},
01262 { 0x0092, 10}, { 0x05CC, 13}, { 0x1EF1, 15}, { 0x00A3, 10}, { 0x03ED, 12}, { 0x093E, 14},
01263 { 0x01E2, 11}, { 0x1273, 15}, { 0x07C4, 11}, { 0x1487, 15}, { 0x0291, 12}, { 0x0293, 12},
01264 { 0x0F8A, 12}, { 0x0509, 13}, { 0x0508, 13}, { 0x078D, 13}, { 0x07BE, 13}, { 0x078C, 13},
01265 { 0x04AE, 14}, { 0x0BBA, 14}, { 0x2307, 14}, { 0x0B9A, 14}, { 0x1736, 15}, { 0x000E, 4},
01266 { 0x0045, 7}, { 0x01F3, 9}, { 0x047A, 11}, { 0x05DC, 13}, { 0x23DF, 14}, { 0x0019, 5},
01267 { 0x0028, 9}, { 0x0176, 11}, { 0x049D, 13}, { 0x23DD, 14}, { 0x0030, 6}, { 0x00A2, 10},
01268 { 0x02EF, 12}, { 0x05B8, 14}, { 0x003F, 6}, { 0x00A5, 10}, { 0x03DB, 12}, { 0x093F, 14},
01269 { 0x0044, 7}, { 0x07CB, 11}, { 0x095F, 15}, { 0x0063, 7}, { 0x03C3, 12}, { 0x0015, 8},
01270 { 0x08F6, 12}, { 0x0017, 8}, { 0x0498, 13}, { 0x002C, 8}, { 0x07B2, 13}, { 0x002F, 8},
01271 { 0x1F54, 13}, { 0x008D, 8}, { 0x07BD, 13}, { 0x008E, 8}, { 0x1182, 13}, { 0x00FB, 8},
01272 { 0x050B, 13}, { 0x002D, 8}, { 0x07C0, 11}, { 0x0079, 9}, { 0x1F5F, 13}, { 0x007A, 9},
01273 { 0x1F56, 13}, { 0x0231, 10}, { 0x03E4, 10}, { 0x01A1, 11}, { 0x0143, 11}, { 0x01F7, 11},
01274 { 0x016F, 12}, { 0x0292, 12}, { 0x02E7, 12}, { 0x016C, 12}, { 0x016D, 12}, { 0x03DC, 12},
01275 { 0x0F8B, 12}, { 0x0499, 13}, { 0x03D8, 12}, { 0x078E, 13}, { 0x02D5, 13}, { 0x1F5E, 13},
01276 { 0x1F2B, 13}, { 0x078F, 13}, { 0x04AD, 14}, { 0x3EAF, 14}, { 0x23DC, 14}, { 0x004A, 9}
01277 },
01278 {
01279 { 0x0000, 3}, { 0x0003, 4}, { 0x000B, 5}, { 0x0014, 6}, { 0x003F, 6}, { 0x005D, 7},
01280 { 0x00A2, 8}, { 0x00AC, 9}, { 0x016E, 9}, { 0x020A, 10}, { 0x02E2, 10}, { 0x0432, 11},
01281 { 0x05C9, 11}, { 0x0827, 12}, { 0x0B54, 12}, { 0x04E6, 13}, { 0x105F, 13}, { 0x172A, 13},
01282 { 0x20B2, 14}, { 0x2D4E, 14}, { 0x39F0, 14}, { 0x4175, 15}, { 0x5A9E, 15}, { 0x0004, 4},
01283 { 0x001E, 5}, { 0x0042, 7}, { 0x00B6, 8}, { 0x0173, 9}, { 0x0395, 10}, { 0x072E, 11},
01284 { 0x0B94, 12}, { 0x16A4, 13}, { 0x20B3, 14}, { 0x2E45, 14}, { 0x0005, 5}, { 0x0040, 7},
01285 { 0x0049, 9}, { 0x028F, 10}, { 0x05CB, 11}, { 0x048A, 13}, { 0x09DD, 14}, { 0x73E2, 15},
01286 { 0x0018, 5}, { 0x0025, 8}, { 0x008A, 10}, { 0x051B, 11}, { 0x0E5F, 12}, { 0x09C9, 14},
01287 { 0x139C, 15}, { 0x0029, 6}, { 0x004F, 9}, { 0x0412, 11}, { 0x048D, 13}, { 0x2E41, 14},
01288 { 0x0038, 6}, { 0x010E, 9}, { 0x05A8, 11}, { 0x105C, 13}, { 0x39F2, 14}, { 0x0058, 7},
01289 { 0x021F, 10}, { 0x0E7E, 12}, { 0x39FF, 14}, { 0x0023, 8}, { 0x02E3, 10}, { 0x04E5, 13},
01290 { 0x2E40, 14}, { 0x00A1, 8}, { 0x05BE, 11}, { 0x09C8, 14}, { 0x0083, 8}, { 0x013A, 11},
01291 { 0x1721, 13}, { 0x0044, 9}, { 0x0276, 12}, { 0x39F6, 14}, { 0x008B, 10}, { 0x04EF, 13},
01292 { 0x5A9B, 15}, { 0x0208, 10}, { 0x1CFE, 13}, { 0x0399, 10}, { 0x1CB4, 13}, { 0x039E, 10},
01293 { 0x39F3, 14}, { 0x05AB, 11}, { 0x73E3, 15}, { 0x0737, 11}, { 0x5A9F, 15}, { 0x082D, 12},
01294 { 0x0E69, 12}, { 0x0E68, 12}, { 0x0433, 11}, { 0x0B7B, 12}, { 0x2DF8, 14}, { 0x2E56, 14},
01295 { 0x2E57, 14}, { 0x39F7, 14}, { 0x51A5, 15}, { 0x0003, 3}, { 0x002A, 6}, { 0x00E4, 8},
01296 { 0x028E, 10}, { 0x0735, 11}, { 0x1058, 13}, { 0x1CFA, 13}, { 0x2DF9, 14}, { 0x4174, 15},
01297 { 0x0009, 4}, { 0x0054, 8}, { 0x0398, 10}, { 0x048B, 13}, { 0x139D, 15}, { 0x000D, 4},
01298 { 0x00AD, 9}, { 0x0826, 12}, { 0x2D4C, 14}, { 0x0011, 5}, { 0x016B, 9}, { 0x0B7F, 12},
01299 { 0x51A4, 15}, { 0x0019, 5}, { 0x021B, 10}, { 0x16FD, 13}, { 0x001D, 5}, { 0x0394, 10},
01300 { 0x28D3, 14}, { 0x002B, 6}, { 0x05BC, 11}, { 0x5A9A, 15}, { 0x002F, 6}, { 0x0247, 12},
01301 { 0x0010, 7}, { 0x0A35, 12}, { 0x003E, 6}, { 0x0B7A, 12}, { 0x0059, 7}, { 0x105E, 13},
01302 { 0x0026, 8}, { 0x09CF, 14}, { 0x0055, 8}, { 0x1CB5, 13}, { 0x0057, 8}, { 0x0E5B, 12},
01303 { 0x00A0, 8}, { 0x1468, 13}, { 0x0170, 9}, { 0x0090, 10}, { 0x01CE, 9}, { 0x021A, 10},
01304 { 0x0218, 10}, { 0x0168, 9}, { 0x021E, 10}, { 0x0244, 12}, { 0x0736, 11}, { 0x0138, 11},
01305 { 0x0519, 11}, { 0x0E5E, 12}, { 0x072C, 11}, { 0x0B55, 12}, { 0x09DC, 14}, { 0x20BB, 14},
01306 { 0x048C, 13}, { 0x1723, 13}, { 0x2E44, 14}, { 0x16A5, 13}, { 0x0518, 11}, { 0x39FE, 14},
01307 { 0x0169, 9}
01308 },
01309 {
01310 { 0x0001, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x0016, 5}, { 0x0020, 6}, { 0x0018, 7},
01311 { 0x0008, 8}, { 0x009A, 8}, { 0x0056, 9}, { 0x013E, 9}, { 0x00F0, 10}, { 0x03A5, 10},
01312 { 0x0077, 11}, { 0x01EF, 11}, { 0x009A, 12}, { 0x005D, 13}, { 0x0001, 4}, { 0x0011, 5},
01313 { 0x0002, 7}, { 0x000B, 8}, { 0x0012, 9}, { 0x01D6, 9}, { 0x027E, 10}, { 0x0191, 11},
01314 { 0x00EA, 12}, { 0x03DC, 12}, { 0x013B, 13}, { 0x0004, 5}, { 0x0014, 7}, { 0x009E, 8},
01315 { 0x0009, 10}, { 0x01AC, 11}, { 0x01E2, 11}, { 0x03CA, 12}, { 0x005F, 13}, { 0x0017, 5},
01316 { 0x004E, 7}, { 0x005E, 9}, { 0x00F3, 10}, { 0x01AD, 11}, { 0x00EC, 12}, { 0x05F0, 13},
01317 { 0x000E, 6}, { 0x00E1, 8}, { 0x03A4, 10}, { 0x009C, 12}, { 0x013D, 13}, { 0x003B, 6},
01318 { 0x001C, 9}, { 0x0014, 11}, { 0x09BE, 12}, { 0x0006, 7}, { 0x007A, 9}, { 0x0190, 11},
01319 { 0x0137, 13}, { 0x001B, 7}, { 0x0008, 10}, { 0x075C, 11}, { 0x0071, 7}, { 0x00D7, 10},
01320 { 0x09BF, 12}, { 0x0007, 8}, { 0x00AF, 10}, { 0x04CC, 11}, { 0x0034, 8}, { 0x0265, 10},
01321 { 0x009F, 12}, { 0x00E0, 8}, { 0x0016, 11}, { 0x0327, 12}, { 0x0015, 9}, { 0x017D, 11},
01322 { 0x0EBB, 12}, { 0x0014, 9}, { 0x00F6, 10}, { 0x01E4, 11}, { 0x00CB, 10}, { 0x099D, 12},
01323 { 0x00CA, 10}, { 0x02FC, 12}, { 0x017F, 11}, { 0x04CD, 11}, { 0x02FD, 12}, { 0x04FE, 11},
01324 { 0x013A, 13}, { 0x000A, 4}, { 0x0042, 7}, { 0x01D3, 9}, { 0x04DD, 11}, { 0x0012, 5},
01325 { 0x00E8, 8}, { 0x004C, 11}, { 0x0136, 13}, { 0x0039, 6}, { 0x0264, 10}, { 0x0EBA, 12},
01326 { 0x0000, 7}, { 0x00AE, 10}, { 0x099C, 12}, { 0x001F, 7}, { 0x04DE, 11}, { 0x0043, 7},
01327 { 0x04DC, 11}, { 0x0003, 8}, { 0x03CB, 12}, { 0x0006, 8}, { 0x099E, 12}, { 0x002A, 8},
01328 { 0x05F1, 13}, { 0x000F, 8}, { 0x09FE, 12}, { 0x0033, 8}, { 0x09FF, 12}, { 0x0098, 8},
01329 { 0x099F, 12}, { 0x00EA, 8}, { 0x013C, 13}, { 0x002E, 8}, { 0x0192, 11}, { 0x0136, 9},
01330 { 0x006A, 9}, { 0x0015, 11}, { 0x03AF, 10}, { 0x01E3, 11}, { 0x0074, 11}, { 0x00EB, 12},
01331 { 0x02F9, 12}, { 0x005C, 13}, { 0x00ED, 12}, { 0x03DD, 12}, { 0x0326, 12}, { 0x005E, 13},
01332 { 0x0016, 7}
01333 },
01334 {
01335 { 0x0004, 3}, { 0x0014, 5}, { 0x0017, 7}, { 0x007F, 8}, { 0x0154, 9}, { 0x01F2, 10},
01336 { 0x00BF, 11}, { 0x0065, 12}, { 0x0AAA, 12}, { 0x0630, 13}, { 0x1597, 13}, { 0x03B7, 14},
01337 { 0x2B22, 14}, { 0x0BE6, 15}, { 0x000B, 4}, { 0x0037, 7}, { 0x0062, 9}, { 0x0007, 11},
01338 { 0x0166, 12}, { 0x00CE, 13}, { 0x1590, 13}, { 0x05F6, 14}, { 0x0BE7, 15}, { 0x0007, 5},
01339 { 0x006D, 8}, { 0x0003, 11}, { 0x031F, 12}, { 0x05F2, 14}, { 0x0002, 6}, { 0x0061, 9},
01340 { 0x0055, 12}, { 0x01DF, 14}, { 0x001A, 6}, { 0x001E, 10}, { 0x0AC9, 12}, { 0x2B23, 14},
01341 { 0x001E, 6}, { 0x001F, 10}, { 0x0AC3, 12}, { 0x2B2B, 14}, { 0x0006, 7}, { 0x0004, 11},
01342 { 0x02F8, 13}, { 0x0019, 7}, { 0x0006, 11}, { 0x063D, 13}, { 0x0057, 7}, { 0x0182, 11},
01343 { 0x2AA2, 14}, { 0x0004, 8}, { 0x0180, 11}, { 0x059C, 14}, { 0x007D, 8}, { 0x0164, 12},
01344 { 0x076D, 15}, { 0x0002, 9}, { 0x018D, 11}, { 0x1581, 13}, { 0x00AD, 8}, { 0x0060, 12},
01345 { 0x0C67, 14}, { 0x001C, 9}, { 0x00EE, 13}, { 0x0003, 9}, { 0x02CF, 13}, { 0x00D9, 9},
01346 { 0x1580, 13}, { 0x0002, 11}, { 0x0183, 11}, { 0x0057, 12}, { 0x0061, 12}, { 0x0031, 11},
01347 { 0x0066, 12}, { 0x0631, 13}, { 0x0632, 13}, { 0x00AC, 13}, { 0x031D, 12}, { 0x0076, 12},
01348 { 0x003A, 11}, { 0x0165, 12}, { 0x0C66, 14}, { 0x0003, 2}, { 0x0054, 7}, { 0x02AB, 10},
01349 { 0x0016, 13}, { 0x05F7, 14}, { 0x0005, 4}, { 0x00F8, 9}, { 0x0AA9, 12}, { 0x005F, 15},
01350 { 0x0004, 4}, { 0x001C, 10}, { 0x1550, 13}, { 0x0004, 5}, { 0x0077, 11}, { 0x076C, 15},
01351 { 0x000E, 5}, { 0x000A, 12}, { 0x000C, 5}, { 0x0562, 11}, { 0x0004, 6}, { 0x031C, 12},
01352 { 0x0006, 6}, { 0x00C8, 13}, { 0x000D, 6}, { 0x01DA, 13}, { 0x0007, 6}, { 0x00C9, 13},
01353 { 0x0001, 7}, { 0x002E, 14}, { 0x0014, 7}, { 0x1596, 13}, { 0x000A, 7}, { 0x0AC2, 12},
01354 { 0x0016, 7}, { 0x015B, 14}, { 0x0015, 7}, { 0x015A, 14}, { 0x000F, 8}, { 0x005E, 15},
01355 { 0x007E, 8}, { 0x00AB, 8}, { 0x002D, 9}, { 0x00D8, 9}, { 0x000B, 9}, { 0x0014, 10},
01356 { 0x02B3, 10}, { 0x01F3, 10}, { 0x003A, 10}, { 0x0000, 10}, { 0x0058, 10}, { 0x002E, 9},
01357 { 0x005E, 10}, { 0x0563, 11}, { 0x00EC, 12}, { 0x0054, 12}, { 0x0AC1, 12}, { 0x1556, 13},
01358 { 0x02FA, 13}, { 0x0181, 11}, { 0x1557, 13}, { 0x059D, 14}, { 0x2AA3, 14}, { 0x2B2A, 14},
01359 { 0x01DE, 14}, { 0x063C, 13}, { 0x00CF, 13}, { 0x1594, 13}, { 0x000D, 9}
01360 },
01361 {
01362 { 0x0002, 2}, { 0x0006, 3}, { 0x000F, 4}, { 0x000D, 5}, { 0x000C, 5}, { 0x0015, 6},
01363 { 0x0013, 6}, { 0x0012, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x001E, 8}, { 0x001D, 8},
01364 { 0x0025, 9}, { 0x0024, 9}, { 0x0023, 9}, { 0x0021, 9}, { 0x0021, 10}, { 0x0020, 10},
01365 { 0x000F, 10}, { 0x000E, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11}, { 0x0021, 11},
01366 { 0x0050, 12}, { 0x0051, 12}, { 0x0052, 12}, { 0x000E, 4}, { 0x0014, 6}, { 0x0016, 7},
01367 { 0x001C, 8}, { 0x0020, 9}, { 0x001F, 9}, { 0x000D, 10}, { 0x0022, 11}, { 0x0053, 12},
01368 { 0x0055, 12}, { 0x000B, 5}, { 0x0015, 7}, { 0x001E, 9}, { 0x000C, 10}, { 0x0056, 12},
01369 { 0x0011, 6}, { 0x001B, 8}, { 0x001D, 9}, { 0x000B, 10}, { 0x0010, 6}, { 0x0022, 9},
01370 { 0x000A, 10}, { 0x000D, 6}, { 0x001C, 9}, { 0x0008, 10}, { 0x0012, 7}, { 0x001B, 9},
01371 { 0x0054, 12}, { 0x0014, 7}, { 0x001A, 9}, { 0x0057, 12}, { 0x0019, 8}, { 0x0009, 10},
01372 { 0x0018, 8}, { 0x0023, 11}, { 0x0017, 8}, { 0x0019, 9}, { 0x0018, 9}, { 0x0007, 10},
01373 { 0x0058, 12}, { 0x0007, 4}, { 0x000C, 6}, { 0x0016, 8}, { 0x0017, 9}, { 0x0006, 10},
01374 { 0x0005, 11}, { 0x0004, 11}, { 0x0059, 12}, { 0x000F, 6}, { 0x0016, 9}, { 0x0005, 10},
01375 { 0x000E, 6}, { 0x0004, 10}, { 0x0011, 7}, { 0x0024, 11}, { 0x0010, 7}, { 0x0025, 11},
01376 { 0x0013, 7}, { 0x005A, 12}, { 0x0015, 8}, { 0x005B, 12}, { 0x0014, 8}, { 0x0013, 8},
01377 { 0x001A, 8}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9}, { 0x0012, 9}, { 0x0011, 9},
01378 { 0x0026, 11}, { 0x0027, 11}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
01379 { 0x0003, 7}
01380 },
01381 {
01382 { 0x0002, 2}, { 0x000F, 4}, { 0x0015, 6}, { 0x0017, 7}, { 0x001F, 8}, { 0x0025, 9},
01383 { 0x0024, 9}, { 0x0021, 10}, { 0x0020, 10}, { 0x0007, 11}, { 0x0006, 11}, { 0x0020, 11},
01384 { 0x0006, 3}, { 0x0014, 6}, { 0x001E, 8}, { 0x000F, 10}, { 0x0021, 11}, { 0x0050, 12},
01385 { 0x000E, 4}, { 0x001D, 8}, { 0x000E, 10}, { 0x0051, 12}, { 0x000D, 5}, { 0x0023, 9},
01386 { 0x000D, 10}, { 0x000C, 5}, { 0x0022, 9}, { 0x0052, 12}, { 0x000B, 5}, { 0x000C, 10},
01387 { 0x0053, 12}, { 0x0013, 6}, { 0x000B, 10}, { 0x0054, 12}, { 0x0012, 6}, { 0x000A, 10},
01388 { 0x0011, 6}, { 0x0009, 10}, { 0x0010, 6}, { 0x0008, 10}, { 0x0016, 7}, { 0x0055, 12},
01389 { 0x0015, 7}, { 0x0014, 7}, { 0x001C, 8}, { 0x001B, 8}, { 0x0021, 9}, { 0x0020, 9},
01390 { 0x001F, 9}, { 0x001E, 9}, { 0x001D, 9}, { 0x001C, 9}, { 0x001B, 9}, { 0x001A, 9},
01391 { 0x0022, 11}, { 0x0023, 11}, { 0x0056, 12}, { 0x0057, 12}, { 0x0007, 4}, { 0x0019, 9},
01392 { 0x0005, 11}, { 0x000F, 6}, { 0x0004, 11}, { 0x000E, 6}, { 0x000D, 6}, { 0x000C, 6},
01393 { 0x0013, 7}, { 0x0012, 7}, { 0x0011, 7}, { 0x0010, 7}, { 0x001A, 8}, { 0x0019, 8},
01394 { 0x0018, 8}, { 0x0017, 8}, { 0x0016, 8}, { 0x0015, 8}, { 0x0014, 8}, { 0x0013, 8},
01395 { 0x0018, 9}, { 0x0017, 9}, { 0x0016, 9}, { 0x0015, 9}, { 0x0014, 9}, { 0x0013, 9},
01396 { 0x0012, 9}, { 0x0011, 9}, { 0x0007, 10}, { 0x0006, 10}, { 0x0005, 10}, { 0x0004, 10},
01397 { 0x0024, 11}, { 0x0025, 11}, { 0x0026, 11}, { 0x0027, 11}, { 0x0058, 12}, { 0x0059, 12},
01398 { 0x005A, 12}, { 0x005B, 12}, { 0x005C, 12}, { 0x005D, 12}, { 0x005E, 12}, { 0x005F, 12},
01399 { 0x0003, 7}
01400 },
01401 {
01402 { 0x0000, 2}, { 0x0003, 3}, { 0x000D, 4}, { 0x0005, 4}, { 0x001C, 5}, { 0x0016, 5},
01403 { 0x003F, 6}, { 0x003A, 6}, { 0x002E, 6}, { 0x0022, 6}, { 0x007B, 7}, { 0x0067, 7},
01404 { 0x005F, 7}, { 0x0047, 7}, { 0x0026, 7}, { 0x00EF, 8}, { 0x00CD, 8}, { 0x00C1, 8},
01405 { 0x00A9, 8}, { 0x004F, 8}, { 0x01F2, 9}, { 0x01DD, 9}, { 0x0199, 9}, { 0x0185, 9},
01406 { 0x015D, 9}, { 0x011B, 9}, { 0x03EF, 10}, { 0x03E1, 10}, { 0x03C8, 10}, { 0x0331, 10},
01407 { 0x0303, 10}, { 0x02F1, 10}, { 0x02A0, 10}, { 0x0233, 10}, { 0x0126, 10}, { 0x07C0, 11},
01408 { 0x076F, 11}, { 0x076C, 11}, { 0x0661, 11}, { 0x0604, 11}, { 0x0572, 11}, { 0x0551, 11},
01409 { 0x046A, 11}, { 0x0274, 11}, { 0x0F27, 12}, { 0x0F24, 12}, { 0x0EDB, 12}, { 0x0C8E, 12},
01410 { 0x0C0B, 12}, { 0x0C0A, 12}, { 0x0AE3, 12}, { 0x08D6, 12}, { 0x0490, 12}, { 0x0495, 12},
01411 { 0x1F19, 13}, { 0x1DB5, 13}, { 0x0009, 4}, { 0x0010, 5}, { 0x0029, 6}, { 0x0062, 7},
01412 { 0x00F3, 8}, { 0x00AD, 8}, { 0x01E5, 9}, { 0x0179, 9}, { 0x009C, 9}, { 0x03B1, 10},
01413 { 0x02AE, 10}, { 0x0127, 10}, { 0x076E, 11}, { 0x0570, 11}, { 0x0275, 11}, { 0x0F25, 12},
01414 { 0x0EC0, 12}, { 0x0AA0, 12}, { 0x08D7, 12}, { 0x1E4C, 13}, { 0x0008, 5}, { 0x0063, 7},
01415 { 0x00AF, 8}, { 0x017B, 9}, { 0x03B3, 10}, { 0x07DD, 11}, { 0x0640, 11}, { 0x0F8D, 12},
01416 { 0x0BC1, 12}, { 0x0491, 12}, { 0x0028, 6}, { 0x00C3, 8}, { 0x0151, 9}, { 0x02A1, 10},
01417 { 0x0573, 11}, { 0x0EC3, 12}, { 0x1F35, 13}, { 0x0065, 7}, { 0x01DA, 9}, { 0x02AF, 10},
01418 { 0x0277, 11}, { 0x08C9, 12}, { 0x1781, 13}, { 0x0025, 7}, { 0x0118, 9}, { 0x0646, 11},
01419 { 0x0AA6, 12}, { 0x1780, 13}, { 0x00C9, 8}, { 0x0321, 10}, { 0x0F9B, 12}, { 0x191E, 13},
01420 { 0x0048, 8}, { 0x07CC, 11}, { 0x0AA1, 12}, { 0x0180, 9}, { 0x0465, 11}, { 0x1905, 13},
01421 { 0x03E2, 10}, { 0x0EC1, 12}, { 0x3C9B, 14}, { 0x02F4, 10}, { 0x08C8, 12}, { 0x07C1, 11},
01422 { 0x0928, 13}, { 0x05E1, 11}, { 0x320D, 14}, { 0x0EC2, 12}, { 0x6418, 15}, { 0x1F34, 13},
01423 { 0x0078, 7}, { 0x0155, 9}, { 0x0552, 11}, { 0x191F, 13}, { 0x00FA, 8}, { 0x07DC, 11},
01424 { 0x1907, 13}, { 0x00AC, 8}, { 0x0249, 11}, { 0x13B1, 14}, { 0x01F6, 9}, { 0x0AE2, 12},
01425 { 0x01DC, 9}, { 0x04ED, 12}, { 0x0184, 9}, { 0x1904, 13}, { 0x0156, 9}, { 0x09D9, 13},
01426 { 0x03E7, 10}, { 0x0929, 13}, { 0x03B2, 10}, { 0x3B68, 14}, { 0x02F5, 10}, { 0x13B0, 14},
01427 { 0x0322, 10}, { 0x3B69, 14}, { 0x0234, 10}, { 0x7935, 15}, { 0x07C7, 11}, { 0xC833, 16},
01428 { 0x0660, 11}, { 0x7934, 15}, { 0x024B, 11}, { 0xC832, 16}, { 0x0AA7, 12}, { 0x1F18, 13},
01429 { 0x007A, 7}
01430 },
01431 {
01432 { 0x0002, 2}, { 0x0000, 3}, { 0x001E, 5}, { 0x0004, 5}, { 0x0012, 6}, { 0x0070, 7},
01433 { 0x001A, 7}, { 0x005F, 8}, { 0x0047, 8}, { 0x01D3, 9}, { 0x00B5, 9}, { 0x0057, 9},
01434 { 0x03B5, 10}, { 0x016D, 10}, { 0x0162, 10}, { 0x07CE, 11}, { 0x0719, 11}, { 0x0691, 11},
01435 { 0x02C6, 11}, { 0x0156, 11}, { 0x0F92, 12}, { 0x0D2E, 12}, { 0x0D20, 12}, { 0x059E, 12},
01436 { 0x0468, 12}, { 0x02A6, 12}, { 0x1DA2, 13}, { 0x1C60, 13}, { 0x1A43, 13}, { 0x0B1D, 13},
01437 { 0x08C0, 13}, { 0x055D, 13}, { 0x0003, 3}, { 0x000A, 5}, { 0x0077, 7}, { 0x00E5, 8},
01438 { 0x01D9, 9}, { 0x03E5, 10}, { 0x0166, 10}, { 0x0694, 11}, { 0x0152, 11}, { 0x059F, 12},
01439 { 0x1F3C, 13}, { 0x1A4B, 13}, { 0x055E, 13}, { 0x000C, 4}, { 0x007D, 7}, { 0x0044, 8},
01440 { 0x03E0, 10}, { 0x0769, 11}, { 0x0E31, 12}, { 0x1F26, 13}, { 0x055C, 13}, { 0x001B, 5},
01441 { 0x00E2, 8}, { 0x03A5, 10}, { 0x02C9, 11}, { 0x1F23, 13}, { 0x3B47, 14}, { 0x0007, 5},
01442 { 0x01D8, 9}, { 0x02D8, 11}, { 0x1F27, 13}, { 0x3494, 14}, { 0x0035, 6}, { 0x03E1, 10},
01443 { 0x059C, 12}, { 0x38C3, 14}, { 0x000C, 6}, { 0x0165, 10}, { 0x1D23, 13}, { 0x1638, 14},
01444 { 0x0068, 7}, { 0x0693, 11}, { 0x3A45, 14}, { 0x0020, 7}, { 0x0F90, 12}, { 0x7CF6, 15},
01445 { 0x00E8, 8}, { 0x058F, 12}, { 0x2CEF, 15}, { 0x0045, 8}, { 0x0B3A, 13}, { 0x01F1, 9},
01446 { 0x3B46, 14}, { 0x01A7, 9}, { 0x1676, 14}, { 0x0056, 9}, { 0x692A, 15}, { 0x038D, 10},
01447 { 0xE309, 16}, { 0x00AA, 10}, { 0x1C611, 17}, { 0x02DF, 11}, { 0xB3B9, 17}, { 0x02C8, 11},
01448 { 0x38C20, 18}, { 0x01B0, 11}, { 0x16390, 18}, { 0x0F9F, 12}, { 0x16771, 18}, { 0x0ED0, 12},
01449 { 0x71843, 19}, { 0x0D2A, 12}, { 0xF9E8C, 20}, { 0x0461, 12}, { 0xF9E8E, 20}, { 0x0B67, 13},
01450 { 0x055F, 13}, { 0x003F, 6}, { 0x006D, 9}, { 0x0E90, 12}, { 0x054E, 13}, { 0x0013, 6},
01451 { 0x0119, 10}, { 0x0B66, 13}, { 0x000B, 6}, { 0x0235, 11}, { 0x7CF5, 15}, { 0x0075, 7},
01452 { 0x0D24, 12}, { 0xF9E9, 16}, { 0x002E, 7}, { 0x1F22, 13}, { 0x0021, 7}, { 0x054F, 13},
01453 { 0x0014, 7}, { 0x3A44, 14}, { 0x00E4, 8}, { 0x7CF7, 15}, { 0x005E, 8}, { 0x7185, 15},
01454 { 0x0037, 8}, { 0x2C73, 15}, { 0x01DB, 9}, { 0x59DD, 16}, { 0x01C7, 9}, { 0x692B, 15},
01455 { 0x01A6, 9}, { 0x58E5, 16}, { 0x00B4, 9}, { 0x1F3D0, 17}, { 0x00B0, 9}, { 0xB1C9, 17},
01456 { 0x03E6, 10}, { 0x16770, 18}, { 0x016E, 10}, { 0x3E7A2, 18}, { 0x011B, 10}, { 0xF9E8D, 20},
01457 { 0x00D9, 10}, { 0xF9E8F, 20}, { 0x00A8, 10}, { 0x2C723, 19}, { 0x0749, 11}, { 0xE3084, 20},
01458 { 0x0696, 11}, { 0x58E45, 20}, { 0x02DE, 11}, { 0xB1C88, 21}, { 0x0231, 11}, { 0x1C610A, 21},
01459 { 0x01B1, 11}, { 0x71842D, 23}, { 0x0D2B, 12}, { 0x38C217, 22}, { 0x0D2F, 12}, { 0x163913, 22},
01460 { 0x05B2, 12}, { 0x163912, 22}, { 0x0469, 12}, { 0x71842C, 23}, { 0x1A42, 13}, { 0x08C1, 13},
01461 { 0x0073, 7}
01462 }
01463 };
01464
01465 static const uint16_t vlc_offs[] = {
01466 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
01467 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
01468 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
01469 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
01470 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
01471 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
01472 31714, 31746, 31778, 32306, 32340, 32372
01473 };
01474
01480 int ff_vc1_init_common(VC1Context *v)
01481 {
01482 static int done = 0;
01483 int i = 0;
01484 static VLC_TYPE vlc_table[32372][2];
01485
01486 v->hrd_rate = v->hrd_buffer = NULL;
01487
01488
01489 if (!done) {
01490 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
01491 ff_vc1_bfraction_bits, 1, 1,
01492 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
01493 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
01494 ff_vc1_norm2_bits, 1, 1,
01495 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
01496 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
01497 ff_vc1_norm6_bits, 1, 1,
01498 ff_vc1_norm6_codes, 2, 2, 556);
01499 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
01500 ff_vc1_imode_bits, 1, 1,
01501 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
01502 for (i = 0; i < 3; i++) {
01503 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
01504 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
01505 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
01506 ff_vc1_ttmb_bits[i], 1, 1,
01507 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01508 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
01509 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
01510 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
01511 ff_vc1_ttblk_bits[i], 1, 1,
01512 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01513 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
01514 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
01515 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
01516 ff_vc1_subblkpat_bits[i], 1, 1,
01517 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01518 }
01519 for (i = 0; i < 4; i++) {
01520 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
01521 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
01522 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
01523 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
01524 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01525 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
01526 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
01527 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
01528 ff_vc1_cbpcy_p_bits[i], 1, 1,
01529 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01530 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
01531 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
01532 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
01533 ff_vc1_mv_diff_bits[i], 1, 1,
01534 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01535 }
01536 for (i = 0; i < 8; i++) {
01537 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
01538 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
01539 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, ff_vc1_ac_sizes[i],
01540 &vc1_ac_tables[i][0][1], 8, 4,
01541 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
01542
01543 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
01544 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
01545 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
01546 ff_vc1_2ref_mvdata_bits[i], 1, 1,
01547 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
01548 }
01549 for (i = 0; i < 4; i++) {
01550
01551 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
01552 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
01553 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
01554 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
01555 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01556
01557 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
01558 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
01559 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
01560 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
01561 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01562
01563 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
01564 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
01565 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
01566 ff_vc1_1ref_mvdata_bits[i], 1, 1,
01567 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
01568 }
01569 for (i = 0; i < 4; i++) {
01570
01571 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
01572 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
01573 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
01574 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
01575 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01576 }
01577 for (i = 0; i < 8; i++) {
01578
01579 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
01580 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
01581 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
01582 ff_vc1_icbpcy_p_bits[i], 1, 1,
01583 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
01584
01585 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
01586 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
01587 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
01588 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
01589 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01590 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
01591 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
01592 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
01593 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
01594 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
01595 }
01596 done = 1;
01597 }
01598
01599
01600 v->pq = -1;
01601 v->mvrange = 0;
01602
01603 return 0;
01604 }