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