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 && nr < 8 && dr && dr < 3) {
00496 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
00497 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
00498 }
00499 }
00500 if (v->broadcast) {
00501 v->s.avctx->time_base.den *= 2;
00502 v->s.avctx->ticks_per_frame = 2;
00503 }
00504 }
00505
00506 if (get_bits1(gb)) {
00507 v->color_prim = get_bits(gb, 8);
00508 v->transfer_char = get_bits(gb, 8);
00509 v->matrix_coef = get_bits(gb, 8);
00510 }
00511 }
00512
00513 v->hrd_param_flag = get_bits1(gb);
00514 if (v->hrd_param_flag) {
00515 int i;
00516 v->hrd_num_leaky_buckets = get_bits(gb, 5);
00517 skip_bits(gb, 4);
00518 skip_bits(gb, 4);
00519 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
00520 skip_bits(gb, 16);
00521 skip_bits(gb, 16);
00522 }
00523 }
00524 return 0;
00525 }
00526
00527 int vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
00528 {
00529 int i;
00530
00531 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
00532 v->broken_link = get_bits1(gb);
00533 v->closed_entry = get_bits1(gb);
00534 v->panscanflag = get_bits1(gb);
00535 v->refdist_flag = get_bits1(gb);
00536 v->s.loop_filter = get_bits1(gb);
00537 v->fastuvmc = get_bits1(gb);
00538 v->extended_mv = get_bits1(gb);
00539 v->dquant = get_bits(gb, 2);
00540 v->vstransform = get_bits1(gb);
00541 v->overlap = get_bits1(gb);
00542 v->quantizer_mode = get_bits(gb, 2);
00543
00544 if (v->hrd_param_flag) {
00545 for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
00546 skip_bits(gb, 8);
00547 }
00548 }
00549
00550 if (get_bits1(gb)) {
00551 avctx->width = avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
00552 avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
00553 }
00554 if (v->extended_mv)
00555 v->extended_dmv = get_bits1(gb);
00556 if ((v->range_mapy_flag = get_bits1(gb))) {
00557 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
00558 v->range_mapy = get_bits(gb, 3);
00559 }
00560 if ((v->range_mapuv_flag = get_bits1(gb))) {
00561 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
00562 v->range_mapuv = get_bits(gb, 3);
00563 }
00564
00565 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
00566 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
00567 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
00568 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
00569 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
00570 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
00571
00572 return 0;
00573 }
00574
00575 int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
00576 {
00577 int pqindex, lowquant, status;
00578
00579 if (v->finterpflag)
00580 v->interpfrm = get_bits1(gb);
00581 skip_bits(gb, 2);
00582 v->rangeredfrm = 0;
00583 if (v->rangered)
00584 v->rangeredfrm = get_bits1(gb);
00585 v->s.pict_type = get_bits1(gb);
00586 if (v->s.avctx->max_b_frames) {
00587 if (!v->s.pict_type) {
00588 if (get_bits1(gb))
00589 v->s.pict_type = AV_PICTURE_TYPE_I;
00590 else
00591 v->s.pict_type = AV_PICTURE_TYPE_B;
00592 } else
00593 v->s.pict_type = AV_PICTURE_TYPE_P;
00594 } else
00595 v->s.pict_type = v->s.pict_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00596
00597 v->bi_type = 0;
00598 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
00599 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00600 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00601 if (v->bfraction == 0) {
00602 v->s.pict_type = AV_PICTURE_TYPE_BI;
00603 }
00604 }
00605 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
00606 skip_bits(gb, 7);
00607
00608 if (v->parse_only)
00609 return 0;
00610
00611
00612 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
00613 v->rnd = 1;
00614 if (v->s.pict_type == AV_PICTURE_TYPE_P)
00615 v->rnd ^= 1;
00616
00617
00618 pqindex = get_bits(gb, 5);
00619 if (!pqindex)
00620 return -1;
00621 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00622 v->pq = ff_vc1_pquant_table[0][pqindex];
00623 else
00624 v->pq = ff_vc1_pquant_table[1][pqindex];
00625
00626 v->pquantizer = 1;
00627 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00628 v->pquantizer = pqindex < 9;
00629 if (v->quantizer_mode == QUANT_NON_UNIFORM)
00630 v->pquantizer = 0;
00631 v->pqindex = pqindex;
00632 if (pqindex < 9)
00633 v->halfpq = get_bits1(gb);
00634 else
00635 v->halfpq = 0;
00636 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
00637 v->pquantizer = get_bits1(gb);
00638 v->dquantfrm = 0;
00639 if (v->extended_mv == 1)
00640 v->mvrange = get_unary(gb, 0, 3);
00641 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
00642 v->k_y = v->mvrange + 8;
00643 v->range_x = 1 << (v->k_x - 1);
00644 v->range_y = 1 << (v->k_y - 1);
00645 if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
00646 v->respic = get_bits(gb, 2);
00647
00648 if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
00649 v->x8_type = get_bits1(gb);
00650 } else
00651 v->x8_type = 0;
00652
00653
00654
00655 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
00656 v->use_ic = 0;
00657
00658 switch (v->s.pict_type) {
00659 case AV_PICTURE_TYPE_P:
00660 if (v->pq < 5) v->tt_index = 0;
00661 else if (v->pq < 13) v->tt_index = 1;
00662 else v->tt_index = 2;
00663
00664 lowquant = (v->pq > 12) ? 0 : 1;
00665 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
00666 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00667 int scale, shift, i;
00668 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
00669 v->lumscale = get_bits(gb, 6);
00670 v->lumshift = get_bits(gb, 6);
00671 v->use_ic = 1;
00672
00673 if (!v->lumscale) {
00674 scale = -64;
00675 shift = (255 - v->lumshift * 2) << 6;
00676 if (v->lumshift > 31)
00677 shift += 128 << 6;
00678 } else {
00679 scale = v->lumscale + 32;
00680 if (v->lumshift > 31)
00681 shift = (v->lumshift - 64) << 6;
00682 else
00683 shift = v->lumshift << 6;
00684 }
00685 for (i = 0; i < 256; i++) {
00686 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
00687 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
00688 }
00689 }
00690 v->qs_last = v->s.quarter_sample;
00691 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
00692 v->s.quarter_sample = 0;
00693 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00694 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
00695 v->s.quarter_sample = 0;
00696 else
00697 v->s.quarter_sample = 1;
00698 } else
00699 v->s.quarter_sample = 1;
00700 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
00701
00702 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
00703 v->mv_mode2 == MV_PMODE_MIXED_MV) ||
00704 v->mv_mode == MV_PMODE_MIXED_MV) {
00705 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
00706 if (status < 0)
00707 return -1;
00708 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
00709 "Imode: %i, Invert: %i\n", status>>1, status&1);
00710 } else {
00711 v->mv_type_is_raw = 0;
00712 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
00713 }
00714 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
00715 if (status < 0)
00716 return -1;
00717 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
00718 "Imode: %i, Invert: %i\n", status>>1, status&1);
00719
00720
00721 v->s.mv_table_index = get_bits(gb, 2);
00722 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
00723
00724 if (v->dquant) {
00725 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
00726 vop_dquant_decoding(v);
00727 }
00728
00729 v->ttfrm = 0;
00730 if (v->vstransform) {
00731 v->ttmbf = get_bits1(gb);
00732 if (v->ttmbf) {
00733 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
00734 }
00735 } else {
00736 v->ttmbf = 1;
00737 v->ttfrm = TT_8X8;
00738 }
00739 break;
00740 case AV_PICTURE_TYPE_B:
00741 if (v->pq < 5) v->tt_index = 0;
00742 else if (v->pq < 13) v->tt_index = 1;
00743 else v->tt_index = 2;
00744
00745 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
00746 v->qs_last = v->s.quarter_sample;
00747 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
00748 v->s.mspel = v->s.quarter_sample;
00749
00750 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
00751 if (status < 0)
00752 return -1;
00753 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
00754 "Imode: %i, Invert: %i\n", status>>1, status&1);
00755 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
00756 if (status < 0)
00757 return -1;
00758 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
00759 "Imode: %i, Invert: %i\n", status>>1, status&1);
00760
00761 v->s.mv_table_index = get_bits(gb, 2);
00762 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
00763
00764 if (v->dquant) {
00765 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
00766 vop_dquant_decoding(v);
00767 }
00768
00769 v->ttfrm = 0;
00770 if (v->vstransform) {
00771 v->ttmbf = get_bits1(gb);
00772 if (v->ttmbf) {
00773 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
00774 }
00775 } else {
00776 v->ttmbf = 1;
00777 v->ttfrm = TT_8X8;
00778 }
00779 break;
00780 }
00781
00782 if (!v->x8_type) {
00783
00784 v->c_ac_table_index = decode012(gb);
00785 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
00786 v->y_ac_table_index = decode012(gb);
00787 }
00788
00789 v->s.dc_table_index = get_bits1(gb);
00790 }
00791
00792 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
00793 v->s.pict_type = AV_PICTURE_TYPE_B;
00794 v->bi_type = 1;
00795 }
00796 return 0;
00797 }
00798
00799
00800 #define INIT_LUT(lumscale, lumshift, luty, lutuv) \
00801 if (!lumscale) { \
00802 scale = -64; \
00803 shift = (255 - lumshift * 2) << 6; \
00804 if (lumshift > 31) \
00805 shift += 128 << 6; \
00806 } else { \
00807 scale = lumscale + 32; \
00808 if (lumshift > 31) \
00809 shift = (lumshift - 64) << 6; \
00810 else \
00811 shift = lumshift << 6; \
00812 } \
00813 for (i = 0; i < 256; i++) { \
00814 luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); \
00815 lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); \
00816 }
00817
00818 int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
00819 {
00820 int pqindex, lowquant;
00821 int status;
00822 int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab;
00823 int scale, shift, i;
00824
00825 v->p_frame_skipped = 0;
00826 if (v->second_field) {
00827 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00828 if (v->fptype & 4)
00829 v->s.pict_type = (v->fptype & 1) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
00830 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
00831 if (!v->pic_header_flag)
00832 goto parse_common_info;
00833 }
00834
00835 v->field_mode = 0;
00836 if (v->interlace) {
00837 v->fcm = decode012(gb);
00838 if (v->fcm) {
00839 if (v->fcm == ILACE_FIELD)
00840 v->field_mode = 1;
00841 if (!v->warn_interlaced++)
00842 av_log(v->s.avctx, AV_LOG_ERROR,
00843 "Interlaced frames/fields support is incomplete\n");
00844 }
00845 } else {
00846 v->fcm = PROGRESSIVE;
00847 }
00848
00849 if (v->field_mode) {
00850 v->fptype = get_bits(gb, 3);
00851 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
00852 if (v->fptype & 4)
00853 v->s.pict_type = (v->fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
00854 } else {
00855 switch (get_unary(gb, 0, 4)) {
00856 case 0:
00857 v->s.pict_type = AV_PICTURE_TYPE_P;
00858 break;
00859 case 1:
00860 v->s.pict_type = AV_PICTURE_TYPE_B;
00861 break;
00862 case 2:
00863 v->s.pict_type = AV_PICTURE_TYPE_I;
00864 break;
00865 case 3:
00866 v->s.pict_type = AV_PICTURE_TYPE_BI;
00867 break;
00868 case 4:
00869 v->s.pict_type = AV_PICTURE_TYPE_P;
00870 v->p_frame_skipped = 1;
00871 break;
00872 }
00873 }
00874 if (v->tfcntrflag)
00875 skip_bits(gb, 8);
00876 if (v->broadcast) {
00877 if (!v->interlace || v->psf) {
00878 v->rptfrm = get_bits(gb, 2);
00879 } else {
00880 v->tff = get_bits1(gb);
00881 v->rff = get_bits1(gb);
00882 }
00883 }
00884 if (v->panscanflag) {
00885 av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
00886
00887 }
00888 if (v->p_frame_skipped) {
00889 return 0;
00890 }
00891 v->rnd = get_bits1(gb);
00892 if (v->interlace)
00893 v->uvsamp = get_bits1(gb);
00894 if (v->field_mode) {
00895 if (!v->refdist_flag)
00896 v->refdist = 0;
00897 else {
00898 if ((v->s.pict_type != AV_PICTURE_TYPE_B)
00899 && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
00900 v->refdist = get_bits(gb, 2);
00901 if (v->refdist == 3)
00902 v->refdist += get_unary(gb, 0, 16);
00903 } else {
00904 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00905 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00906 v->frfd = (v->bfraction * v->refdist) >> 8;
00907 v->brfd = v->refdist - v->frfd - 1;
00908 if (v->brfd < 0)
00909 v->brfd = 0;
00910 }
00911 }
00912 goto parse_common_info;
00913 }
00914 if (v->finterpflag)
00915 v->interpfrm = get_bits1(gb);
00916 if (v->s.pict_type == AV_PICTURE_TYPE_B) {
00917 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00918 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00919 if (v->bfraction == 0) {
00920 v->s.pict_type = AV_PICTURE_TYPE_BI;
00921 }
00922 }
00923
00924 parse_common_info:
00925 if (v->field_mode)
00926 v->cur_field_type = !(v->tff ^ v->second_field);
00927 pqindex = get_bits(gb, 5);
00928 if (!pqindex)
00929 return -1;
00930 v->pqindex = pqindex;
00931 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00932 v->pq = ff_vc1_pquant_table[0][pqindex];
00933 else
00934 v->pq = ff_vc1_pquant_table[1][pqindex];
00935
00936 v->pquantizer = 1;
00937 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00938 v->pquantizer = pqindex < 9;
00939 if (v->quantizer_mode == QUANT_NON_UNIFORM)
00940 v->pquantizer = 0;
00941 v->pqindex = pqindex;
00942 if (pqindex < 9)
00943 v->halfpq = get_bits1(gb);
00944 else
00945 v->halfpq = 0;
00946 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
00947 v->pquantizer = get_bits1(gb);
00948 if (v->postprocflag)
00949 v->postproc = get_bits(gb, 2);
00950
00951 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_P)
00952 v->use_ic = 0;
00953
00954 if (v->parse_only)
00955 return 0;
00956
00957 switch (v->s.pict_type) {
00958 case AV_PICTURE_TYPE_I:
00959 case AV_PICTURE_TYPE_BI:
00960 if (v->fcm == ILACE_FRAME) {
00961 status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
00962 if (status < 0)
00963 return -1;
00964 av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
00965 "Imode: %i, Invert: %i\n", status>>1, status&1);
00966 }
00967 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
00968 if (status < 0)
00969 return -1;
00970 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
00971 "Imode: %i, Invert: %i\n", status>>1, status&1);
00972 v->condover = CONDOVER_NONE;
00973 if (v->overlap && v->pq <= 8) {
00974 v->condover = decode012(gb);
00975 if (v->condover == CONDOVER_SELECT) {
00976 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
00977 if (status < 0)
00978 return -1;
00979 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
00980 "Imode: %i, Invert: %i\n", status>>1, status&1);
00981 }
00982 }
00983 break;
00984 case AV_PICTURE_TYPE_P:
00985 if (v->field_mode) {
00986 v->numref = get_bits1(gb);
00987 if (!v->numref) {
00988 v->reffield = get_bits1(gb);
00989 v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
00990 }
00991 }
00992 if (v->extended_mv)
00993 v->mvrange = get_unary(gb, 0, 3);
00994 else
00995 v->mvrange = 0;
00996 if (v->interlace) {
00997 if (v->extended_dmv)
00998 v->dmvrange = get_unary(gb, 0, 3);
00999 else
01000 v->dmvrange = 0;
01001 if (v->fcm == ILACE_FRAME) {
01002 v->fourmvswitch = get_bits1(gb);
01003 v->intcomp = get_bits1(gb);
01004 if (v->intcomp) {
01005 v->lumscale = get_bits(gb, 6);
01006 v->lumshift = get_bits(gb, 6);
01007 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
01008 }
01009 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01010 av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
01011 "Imode: %i, Invert: %i\n", status>>1, status&1);
01012 mbmodetab = get_bits(gb, 2);
01013 if (v->fourmvswitch)
01014 v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
01015 else
01016 v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
01017 imvtab = get_bits(gb, 2);
01018 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
01019
01020 icbptab = get_bits(gb, 3);
01021 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01022 twomvbptab = get_bits(gb, 2);
01023 v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
01024 if (v->fourmvswitch) {
01025 fourmvbptab = get_bits(gb, 2);
01026 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01027 }
01028 }
01029 }
01030 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
01031 v->k_y = v->mvrange + 8;
01032 v->range_x = 1 << (v->k_x - 1);
01033 v->range_y = 1 << (v->k_y - 1);
01034
01035 if (v->pq < 5)
01036 v->tt_index = 0;
01037 else if (v->pq < 13)
01038 v->tt_index = 1;
01039 else
01040 v->tt_index = 2;
01041 if (v->fcm != ILACE_FRAME) {
01042 int mvmode;
01043 mvmode = get_unary(gb, 1, 4);
01044 lowquant = (v->pq > 12) ? 0 : 1;
01045 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
01046 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01047 int mvmode2;
01048 mvmode2 = get_unary(gb, 1, 3);
01049 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
01050 if (v->field_mode)
01051 v->intcompfield = decode210(gb);
01052 v->lumscale = get_bits(gb, 6);
01053 v->lumshift = get_bits(gb, 6);
01054 INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
01055 if ((v->field_mode) && !v->intcompfield) {
01056 v->lumscale2 = get_bits(gb, 6);
01057 v->lumshift2 = get_bits(gb, 6);
01058 INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
01059 }
01060 v->use_ic = 1;
01061 }
01062 v->qs_last = v->s.quarter_sample;
01063 if (v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
01064 v->s.quarter_sample = 0;
01065 else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01066 if (v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
01067 v->s.quarter_sample = 0;
01068 else
01069 v->s.quarter_sample = 1;
01070 } else
01071 v->s.quarter_sample = 1;
01072 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
01073 || (v->mv_mode == MV_PMODE_INTENSITY_COMP
01074 && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
01075 }
01076 if (v->fcm == PROGRESSIVE) {
01077 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01078 v->mv_mode2 == MV_PMODE_MIXED_MV)
01079 || v->mv_mode == MV_PMODE_MIXED_MV) {
01080 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
01081 if (status < 0)
01082 return -1;
01083 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
01084 "Imode: %i, Invert: %i\n", status>>1, status&1);
01085 } else {
01086 v->mv_type_is_raw = 0;
01087 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
01088 }
01089 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01090 if (status < 0)
01091 return -1;
01092 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01093 "Imode: %i, Invert: %i\n", status>>1, status&1);
01094
01095
01096 v->s.mv_table_index = get_bits(gb, 2);
01097 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01098 } else if (v->fcm == ILACE_FRAME) {
01099 v->qs_last = v->s.quarter_sample;
01100 v->s.quarter_sample = 1;
01101 v->s.mspel = 1;
01102 } else {
01103 mbmodetab = get_bits(gb, 3);
01104 imvtab = get_bits(gb, 2 + v->numref);
01105 if (!v->numref)
01106 v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
01107 else
01108 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
01109 icbptab = get_bits(gb, 3);
01110 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01111 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01112 v->mv_mode2 == MV_PMODE_MIXED_MV) || v->mv_mode == MV_PMODE_MIXED_MV) {
01113 fourmvbptab = get_bits(gb, 2);
01114 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01115 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
01116 } else {
01117 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
01118 }
01119 }
01120 if (v->dquant) {
01121 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01122 vop_dquant_decoding(v);
01123 }
01124
01125 v->ttfrm = 0;
01126 if (v->vstransform) {
01127 v->ttmbf = get_bits1(gb);
01128 if (v->ttmbf) {
01129 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01130 }
01131 } else {
01132 v->ttmbf = 1;
01133 v->ttfrm = TT_8X8;
01134 }
01135 break;
01136 case AV_PICTURE_TYPE_B:
01137
01138 if (v->fcm == ILACE_FRAME)
01139 return -1;
01140 if (v->extended_mv)
01141 v->mvrange = get_unary(gb, 0, 3);
01142 else
01143 v->mvrange = 0;
01144 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
01145 v->k_y = v->mvrange + 8;
01146 v->range_x = 1 << (v->k_x - 1);
01147 v->range_y = 1 << (v->k_y - 1);
01148
01149 if (v->pq < 5)
01150 v->tt_index = 0;
01151 else if (v->pq < 13)
01152 v->tt_index = 1;
01153 else
01154 v->tt_index = 2;
01155
01156 if (v->field_mode) {
01157 int mvmode;
01158 if (v->extended_dmv)
01159 v->dmvrange = get_unary(gb, 0, 3);
01160 mvmode = get_unary(gb, 1, 3);
01161 lowquant = (v->pq > 12) ? 0 : 1;
01162 v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
01163 v->qs_last = v->s.quarter_sample;
01164 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV || v->mv_mode == MV_PMODE_MIXED_MV);
01165 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || v->mv_mode == MV_PMODE_1MV_HPEL);
01166 status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
01167 if (status < 0)
01168 return -1;
01169 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
01170 "Imode: %i, Invert: %i\n", status>>1, status&1);
01171 mbmodetab = get_bits(gb, 3);
01172 if (v->mv_mode == MV_PMODE_MIXED_MV)
01173 v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
01174 else
01175 v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
01176 imvtab = get_bits(gb, 3);
01177 v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
01178 icbptab = get_bits(gb, 3);
01179 v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
01180 if (v->mv_mode == MV_PMODE_MIXED_MV) {
01181 fourmvbptab = get_bits(gb, 2);
01182 v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
01183 }
01184 v->numref = 1;
01185 } else {
01186 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
01187 v->qs_last = v->s.quarter_sample;
01188 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
01189 v->s.mspel = v->s.quarter_sample;
01190 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
01191 if (status < 0)
01192 return -1;
01193 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
01194 "Imode: %i, Invert: %i\n", status>>1, status&1);
01195 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01196 if (status < 0)
01197 return -1;
01198 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01199 "Imode: %i, Invert: %i\n", status>>1, status&1);
01200 v->s.mv_table_index = get_bits(gb, 2);
01201 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01202 }
01203
01204 if (v->dquant) {
01205 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01206 vop_dquant_decoding(v);
01207 }
01208
01209 v->ttfrm = 0;
01210 if (v->vstransform) {
01211 v->ttmbf = get_bits1(gb);
01212 if (v->ttmbf) {
01213 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01214 }
01215 } else {
01216 v->ttmbf = 1;
01217 v->ttfrm = TT_8X8;
01218 }
01219 break;
01220 }
01221
01222
01223 v->c_ac_table_index = decode012(gb);
01224 if (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI) {
01225 v->y_ac_table_index = decode012(gb);
01226 }
01227
01228 v->s.dc_table_index = get_bits1(gb);
01229 if ((v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)
01230 && v->dquant) {
01231 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01232 vop_dquant_decoding(v);
01233 }
01234
01235 v->bi_type = 0;
01236 if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
01237 v->s.pict_type = AV_PICTURE_TYPE_B;
01238 v->bi_type = 1;
01239 }
01240 return 0;
01241 }