00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00028 #include "internal.h"
00029 #include "dsputil.h"
00030 #include "avcodec.h"
00031 #include "mpegvideo.h"
00032 #include "vc1.h"
00033 #include "vc1data.h"
00034 #include "msmpeg4data.h"
00035 #include "unary.h"
00036 #include "simple_idct.h"
00037
00038 #undef NDEBUG
00039 #include <assert.h>
00040
00041
00052 enum Imode {
00053 IMODE_RAW,
00054 IMODE_NORM2,
00055 IMODE_DIFF2,
00056 IMODE_NORM6,
00057 IMODE_DIFF6,
00058 IMODE_ROWSKIP,
00059 IMODE_COLSKIP
00060 };
00062
00069 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
00070 int x, y;
00071
00072 for (y=0; y<height; y++){
00073 if (!get_bits1(gb))
00074 memset(plane, 0, width);
00075 else
00076 for (x=0; x<width; x++)
00077 plane[x] = get_bits1(gb);
00078 plane += stride;
00079 }
00080 }
00081
00089 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
00090 int x, y;
00091
00092 for (x=0; x<width; x++){
00093 if (!get_bits1(gb))
00094 for (y=0; y<height; y++)
00095 plane[y*stride] = 0;
00096 else
00097 for (y=0; y<height; y++)
00098 plane[y*stride] = get_bits1(gb);
00099 plane ++;
00100 }
00101 }
00102
00110 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
00111 {
00112 GetBitContext *gb = &v->s.gb;
00113
00114 int imode, x, y, code, offset;
00115 uint8_t invert, *planep = data;
00116 int width, height, stride;
00117
00118 width = v->s.mb_width;
00119 height = v->s.mb_height;
00120 stride = v->s.mb_stride;
00121 invert = get_bits1(gb);
00122 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
00123
00124 *raw_flag = 0;
00125 switch (imode)
00126 {
00127 case IMODE_RAW:
00128
00129 *raw_flag = 1;
00130 return invert;
00131 case IMODE_DIFF2:
00132 case IMODE_NORM2:
00133 if ((height * width) & 1)
00134 {
00135 *planep++ = get_bits1(gb);
00136 offset = 1;
00137 }
00138 else offset = 0;
00139
00140 for (y = offset; y < height * width; y += 2) {
00141 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
00142 *planep++ = code & 1;
00143 offset++;
00144 if(offset == width) {
00145 offset = 0;
00146 planep += stride - width;
00147 }
00148 *planep++ = code >> 1;
00149 offset++;
00150 if(offset == width) {
00151 offset = 0;
00152 planep += stride - width;
00153 }
00154 }
00155 break;
00156 case IMODE_DIFF6:
00157 case IMODE_NORM6:
00158 if(!(height % 3) && (width % 3)) {
00159 for(y = 0; y < height; y+= 3) {
00160 for(x = width & 1; x < width; x += 2) {
00161 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
00162 if(code < 0){
00163 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
00164 return -1;
00165 }
00166 planep[x + 0] = (code >> 0) & 1;
00167 planep[x + 1] = (code >> 1) & 1;
00168 planep[x + 0 + stride] = (code >> 2) & 1;
00169 planep[x + 1 + stride] = (code >> 3) & 1;
00170 planep[x + 0 + stride * 2] = (code >> 4) & 1;
00171 planep[x + 1 + stride * 2] = (code >> 5) & 1;
00172 }
00173 planep += stride * 3;
00174 }
00175 if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
00176 } else {
00177 planep += (height & 1) * stride;
00178 for(y = height & 1; y < height; y += 2) {
00179 for(x = width % 3; x < width; x += 3) {
00180 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
00181 if(code < 0){
00182 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
00183 return -1;
00184 }
00185 planep[x + 0] = (code >> 0) & 1;
00186 planep[x + 1] = (code >> 1) & 1;
00187 planep[x + 2] = (code >> 2) & 1;
00188 planep[x + 0 + stride] = (code >> 3) & 1;
00189 planep[x + 1 + stride] = (code >> 4) & 1;
00190 planep[x + 2 + stride] = (code >> 5) & 1;
00191 }
00192 planep += stride * 2;
00193 }
00194 x = width % 3;
00195 if(x) decode_colskip(data , x, height , stride, &v->s.gb);
00196 if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
00197 }
00198 break;
00199 case IMODE_ROWSKIP:
00200 decode_rowskip(data, width, height, stride, &v->s.gb);
00201 break;
00202 case IMODE_COLSKIP:
00203 decode_colskip(data, width, height, stride, &v->s.gb);
00204 break;
00205 default: break;
00206 }
00207
00208
00209 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
00210 {
00211 planep = data;
00212 planep[0] ^= invert;
00213 for (x=1; x<width; x++)
00214 planep[x] ^= planep[x-1];
00215 for (y=1; y<height; y++)
00216 {
00217 planep += stride;
00218 planep[0] ^= planep[-stride];
00219 for (x=1; x<width; x++)
00220 {
00221 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
00222 else planep[x] ^= planep[x-1];
00223 }
00224 }
00225 }
00226 else if (invert)
00227 {
00228 planep = data;
00229 for (x=0; x<stride*height; x++) planep[x] = !planep[x];
00230 }
00231 return (imode<<1) + invert;
00232 }
00233
00235
00236
00240 static int vop_dquant_decoding(VC1Context *v)
00241 {
00242 GetBitContext *gb = &v->s.gb;
00243 int pqdiff;
00244
00245
00246 if (v->dquant == 2)
00247 {
00248 pqdiff = get_bits(gb, 3);
00249 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
00250 else v->altpq = v->pq + pqdiff + 1;
00251 }
00252 else
00253 {
00254 v->dquantfrm = get_bits1(gb);
00255 if ( v->dquantfrm )
00256 {
00257 v->dqprofile = get_bits(gb, 2);
00258 switch (v->dqprofile)
00259 {
00260 case DQPROFILE_SINGLE_EDGE:
00261 case DQPROFILE_DOUBLE_EDGES:
00262 v->dqsbedge = get_bits(gb, 2);
00263 break;
00264 case DQPROFILE_ALL_MBS:
00265 v->dqbilevel = get_bits1(gb);
00266 if(!v->dqbilevel)
00267 v->halfpq = 0;
00268 default: break;
00269 }
00270 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
00271 {
00272 pqdiff = get_bits(gb, 3);
00273 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
00274 else v->altpq = v->pq + pqdiff + 1;
00275 }
00276 }
00277 }
00278 return 0;
00279 }
00280
00281 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
00282
00283 static void simple_idct_put_rangered(uint8_t *dest, int line_size, DCTELEM *block)
00284 {
00285 int i;
00286 ff_simple_idct(block);
00287 for (i = 0; i < 64; i++) block[i] = (block[i] - 64) << 1;
00288 ff_put_pixels_clamped_c(block, dest, line_size);
00289 }
00290
00291 static void simple_idct_put_signed(uint8_t *dest, int line_size, DCTELEM *block)
00292 {
00293 ff_simple_idct(block);
00294 ff_put_signed_pixels_clamped_c(block, dest, line_size);
00295 }
00296
00297 static void simple_idct_put_signed_rangered(uint8_t *dest, int line_size, DCTELEM *block)
00298 {
00299 int i;
00300 ff_simple_idct(block);
00301 for (i = 0; i < 64; i++) block[i] <<= 1;
00302 ff_put_signed_pixels_clamped_c(block, dest, line_size);
00303 }
00304
00312 int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
00313 {
00314 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
00315 v->profile = get_bits(gb, 2);
00316 if (v->profile == PROFILE_COMPLEX)
00317 {
00318 av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
00319 }
00320
00321 if (v->profile == PROFILE_ADVANCED)
00322 {
00323 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
00324 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
00325 return decode_sequence_header_adv(v, gb);
00326 }
00327 else
00328 {
00329 v->zz_8x4 = wmv2_scantableA;
00330 v->zz_4x8 = wmv2_scantableB;
00331 v->res_y411 = get_bits1(gb);
00332 v->res_sprite = get_bits1(gb);
00333 if (v->res_y411)
00334 {
00335 av_log(avctx, AV_LOG_ERROR,
00336 "Old interlaced mode is not supported\n");
00337 return -1;
00338 }
00339 if (v->res_sprite) {
00340 av_log(avctx, AV_LOG_ERROR, "WMVP is not fully supported\n");
00341 }
00342 }
00343
00344
00345 v->frmrtq_postproc = get_bits(gb, 3);
00346
00347 v->bitrtq_postproc = get_bits(gb, 5);
00348 v->s.loop_filter = get_bits1(gb);
00349 if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
00350 {
00351 av_log(avctx, AV_LOG_ERROR,
00352 "LOOPFILTER shall not be enabled in Simple Profile\n");
00353 }
00354 if(v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
00355 v->s.loop_filter = 0;
00356
00357 v->res_x8 = get_bits1(gb);
00358 v->multires = get_bits1(gb);
00359 v->res_fasttx = get_bits1(gb);
00360 if (!v->res_fasttx)
00361 {
00362 v->vc1dsp.vc1_inv_trans_8x8_add = ff_simple_idct_add;
00363 v->vc1dsp.vc1_inv_trans_8x8_put[0] = ff_simple_idct_put;
00364 v->vc1dsp.vc1_inv_trans_8x8_put[1] = simple_idct_put_rangered;
00365 v->vc1dsp.vc1_inv_trans_8x8_put_signed[0] = simple_idct_put_signed;
00366 v->vc1dsp.vc1_inv_trans_8x8_put_signed[1] = simple_idct_put_signed_rangered;
00367 v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
00368 v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
00369 v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
00370 v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add;
00371 v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
00372 v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
00373 v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;
00374 }
00375
00376 v->fastuvmc = get_bits1(gb);
00377 if (!v->profile && !v->fastuvmc)
00378 {
00379 av_log(avctx, AV_LOG_ERROR,
00380 "FASTUVMC unavailable in Simple Profile\n");
00381 return -1;
00382 }
00383 v->extended_mv = get_bits1(gb);
00384 if (!v->profile && v->extended_mv)
00385 {
00386 av_log(avctx, AV_LOG_ERROR,
00387 "Extended MVs unavailable in Simple Profile\n");
00388 return -1;
00389 }
00390 v->dquant = get_bits(gb, 2);
00391 v->vstransform = get_bits1(gb);
00392
00393 v->res_transtab = get_bits1(gb);
00394 if (v->res_transtab)
00395 {
00396 av_log(avctx, AV_LOG_ERROR,
00397 "1 for reserved RES_TRANSTAB is forbidden\n");
00398 return -1;
00399 }
00400
00401 v->overlap = get_bits1(gb);
00402
00403 v->s.resync_marker = get_bits1(gb);
00404 v->rangered = get_bits1(gb);
00405 if (v->rangered && v->profile == PROFILE_SIMPLE)
00406 {
00407 av_log(avctx, AV_LOG_INFO,
00408 "RANGERED should be set to 0 in Simple Profile\n");
00409 }
00410
00411 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3);
00412 v->quantizer_mode = get_bits(gb, 2);
00413
00414 v->finterpflag = get_bits1(gb);
00415
00416 if (v->res_sprite) {
00417 v->s.avctx->width = v->s.avctx->coded_width = get_bits(gb, 11);
00418 v->s.avctx->height = v->s.avctx->coded_height = get_bits(gb, 11);
00419 skip_bits(gb, 5);
00420 v->res_x8 = get_bits1(gb);
00421 if (get_bits1(gb)) {
00422 av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
00423 return -1;
00424 }
00425 skip_bits(gb, 3);
00426 v->res_rtm_flag = 0;
00427 } else {
00428 v->res_rtm_flag = get_bits1(gb);
00429 }
00430 if (!v->res_rtm_flag)
00431 {
00432
00433
00434 av_log(avctx, AV_LOG_ERROR,
00435 "Old WMV3 version detected, some frames may be decoded incorrectly\n");
00436
00437 }
00438
00439 if(!v->res_fasttx) skip_bits(gb, 16);
00440 av_log(avctx, AV_LOG_DEBUG,
00441 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
00442 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
00443 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
00444 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
00445 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
00446 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
00447 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
00448 v->dquant, v->quantizer_mode, avctx->max_b_frames
00449 );
00450 return 0;
00451 }
00452
00453 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
00454 {
00455 v->res_rtm_flag = 1;
00456 v->level = get_bits(gb, 3);
00457 if(v->level >= 5)
00458 {
00459 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
00460 }
00461 v->chromaformat = get_bits(gb, 2);
00462 if (v->chromaformat != 1)
00463 {
00464 av_log(v->s.avctx, AV_LOG_ERROR,
00465 "Only 4:2:0 chroma format supported\n");
00466 return -1;
00467 }
00468
00469
00470 v->frmrtq_postproc = get_bits(gb, 3);
00471
00472 v->bitrtq_postproc = get_bits(gb, 5);
00473 v->postprocflag = get_bits1(gb);
00474
00475 v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
00476 v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
00477 v->s.avctx->width = v->s.avctx->coded_width;
00478 v->s.avctx->height = v->s.avctx->coded_height;
00479 v->broadcast = get_bits1(gb);
00480 v->interlace = get_bits1(gb);
00481 v->tfcntrflag = get_bits1(gb);
00482 v->finterpflag = get_bits1(gb);
00483 skip_bits1(gb);
00484
00485 v->s.h_edge_pos = v->s.avctx->coded_width;
00486 v->s.v_edge_pos = v->s.avctx->coded_height;
00487
00488 av_log(v->s.avctx, AV_LOG_DEBUG,
00489 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
00490 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
00491 "TFCTRflag=%i, FINTERPflag=%i\n",
00492 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
00493 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
00494 v->tfcntrflag, v->finterpflag
00495 );
00496
00497 v->psf = get_bits1(gb);
00498 if(v->psf) {
00499 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
00500 return -1;
00501 }
00502 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
00503 if(get_bits1(gb)) {
00504 int w, h, ar = 0;
00505 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
00506 v->s.avctx->width = w = get_bits(gb, 14) + 1;
00507 v->s.avctx->height = h = get_bits(gb, 14) + 1;
00508 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
00509 if(get_bits1(gb))
00510 ar = get_bits(gb, 4);
00511 if(ar && ar < 14){
00512 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
00513 }else if(ar == 15){
00514 w = get_bits(gb, 8);
00515 h = get_bits(gb, 8);
00516 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
00517 }
00518 av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n", v->s.avctx->sample_aspect_ratio.num, v->s.avctx->sample_aspect_ratio.den);
00519
00520 if(get_bits1(gb)){
00521 if(get_bits1(gb)) {
00522 v->s.avctx->time_base.num = 32;
00523 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
00524 } else {
00525 int nr, dr;
00526 nr = get_bits(gb, 8);
00527 dr = get_bits(gb, 4);
00528 if(nr && nr < 8 && dr && dr < 3){
00529 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
00530 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
00531 }
00532 }
00533 }
00534
00535 if(get_bits1(gb)){
00536 v->color_prim = get_bits(gb, 8);
00537 v->transfer_char = get_bits(gb, 8);
00538 v->matrix_coef = get_bits(gb, 8);
00539 }
00540 }
00541
00542 v->hrd_param_flag = get_bits1(gb);
00543 if(v->hrd_param_flag) {
00544 int i;
00545 v->hrd_num_leaky_buckets = get_bits(gb, 5);
00546 skip_bits(gb, 4);
00547 skip_bits(gb, 4);
00548 for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
00549 skip_bits(gb, 16);
00550 skip_bits(gb, 16);
00551 }
00552 }
00553 return 0;
00554 }
00555
00556 int vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb)
00557 {
00558 int i;
00559
00560 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
00561 v->broken_link = get_bits1(gb);
00562 v->closed_entry = get_bits1(gb);
00563 v->panscanflag = get_bits1(gb);
00564 v->refdist_flag = get_bits1(gb);
00565 v->s.loop_filter = get_bits1(gb);
00566 v->fastuvmc = get_bits1(gb);
00567 v->extended_mv = get_bits1(gb);
00568 v->dquant = get_bits(gb, 2);
00569 v->vstransform = get_bits1(gb);
00570 v->overlap = get_bits1(gb);
00571 v->quantizer_mode = get_bits(gb, 2);
00572
00573 if(v->hrd_param_flag){
00574 for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
00575 skip_bits(gb, 8);
00576 }
00577 }
00578
00579 if(get_bits1(gb)){
00580 avctx->coded_width = (get_bits(gb, 12)+1)<<1;
00581 avctx->coded_height = (get_bits(gb, 12)+1)<<1;
00582 }
00583 if(v->extended_mv)
00584 v->extended_dmv = get_bits1(gb);
00585 if((v->range_mapy_flag = get_bits1(gb))) {
00586 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
00587 v->range_mapy = get_bits(gb, 3);
00588 }
00589 if((v->range_mapuv_flag = get_bits1(gb))) {
00590 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
00591 v->range_mapuv = get_bits(gb, 3);
00592 }
00593
00594 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
00595 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
00596 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
00597 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
00598 v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
00599 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
00600
00601 return 0;
00602 }
00603
00604 int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
00605 {
00606 int pqindex, lowquant, status;
00607
00608 if(v->res_sprite) {
00609 skip_bits(gb, 2);
00610 }
00611 if(v->finterpflag) v->interpfrm = get_bits1(gb);
00612 skip_bits(gb, 2);
00613 v->rangeredfrm = 0;
00614 if (v->rangered) v->rangeredfrm = get_bits1(gb);
00615 v->s.pict_type = get_bits1(gb);
00616 if (v->s.avctx->max_b_frames) {
00617 if (!v->s.pict_type) {
00618 if (get_bits1(gb)) v->s.pict_type = FF_I_TYPE;
00619 else v->s.pict_type = FF_B_TYPE;
00620 } else v->s.pict_type = FF_P_TYPE;
00621 } else v->s.pict_type = v->s.pict_type ? FF_P_TYPE : FF_I_TYPE;
00622
00623 v->bi_type = 0;
00624 if(v->s.pict_type == FF_B_TYPE) {
00625 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00626 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00627 if(v->bfraction == 0) {
00628 v->s.pict_type = FF_BI_TYPE;
00629 }
00630 }
00631 if(v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE)
00632 skip_bits(gb, 7);
00633
00634 if(v->parse_only)
00635 return 0;
00636
00637
00638 if(v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE)
00639 v->rnd = 1;
00640 if(v->s.pict_type == FF_P_TYPE)
00641 v->rnd ^= 1;
00642
00643
00644 pqindex = get_bits(gb, 5);
00645 if(!pqindex) return -1;
00646 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00647 v->pq = ff_vc1_pquant_table[0][pqindex];
00648 else
00649 v->pq = ff_vc1_pquant_table[1][pqindex];
00650
00651 v->pquantizer = 1;
00652 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00653 v->pquantizer = pqindex < 9;
00654 if (v->quantizer_mode == QUANT_NON_UNIFORM)
00655 v->pquantizer = 0;
00656 v->pqindex = pqindex;
00657 if (pqindex < 9) v->halfpq = get_bits1(gb);
00658 else v->halfpq = 0;
00659 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
00660 v->pquantizer = get_bits1(gb);
00661 v->dquantfrm = 0;
00662 if (v->extended_mv == 1) v->mvrange = get_unary(gb, 0, 3);
00663 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
00664 v->k_y = v->mvrange + 8;
00665 v->range_x = 1 << (v->k_x - 1);
00666 v->range_y = 1 << (v->k_y - 1);
00667 if (v->multires && v->s.pict_type != FF_B_TYPE) v->respic = get_bits(gb, 2);
00668
00669 if(v->res_x8 && (v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE)){
00670 v->x8_type = get_bits1(gb);
00671 }else v->x8_type = 0;
00672
00673
00674
00675 if(v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_P_TYPE) v->use_ic = 0;
00676
00677 switch(v->s.pict_type) {
00678 case FF_P_TYPE:
00679 if (v->pq < 5) v->tt_index = 0;
00680 else if(v->pq < 13) v->tt_index = 1;
00681 else v->tt_index = 2;
00682
00683 lowquant = (v->pq > 12) ? 0 : 1;
00684 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
00685 if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00686 {
00687 int scale, shift, i;
00688 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
00689 v->lumscale = get_bits(gb, 6);
00690 v->lumshift = get_bits(gb, 6);
00691 v->use_ic = 1;
00692
00693 if(!v->lumscale) {
00694 scale = -64;
00695 shift = (255 - v->lumshift * 2) << 6;
00696 if(v->lumshift > 31)
00697 shift += 128 << 6;
00698 } else {
00699 scale = v->lumscale + 32;
00700 if(v->lumshift > 31)
00701 shift = (v->lumshift - 64) << 6;
00702 else
00703 shift = v->lumshift << 6;
00704 }
00705 for(i = 0; i < 256; i++) {
00706 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
00707 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
00708 }
00709 }
00710 if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
00711 v->s.quarter_sample = 0;
00712 else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00713 if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
00714 v->s.quarter_sample = 0;
00715 else
00716 v->s.quarter_sample = 1;
00717 } else
00718 v->s.quarter_sample = 1;
00719 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));
00720
00721 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
00722 v->mv_mode2 == MV_PMODE_MIXED_MV)
00723 || v->mv_mode == MV_PMODE_MIXED_MV)
00724 {
00725 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
00726 if (status < 0) return -1;
00727 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
00728 "Imode: %i, Invert: %i\n", status>>1, status&1);
00729 } else {
00730 v->mv_type_is_raw = 0;
00731 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
00732 }
00733 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
00734 if (status < 0) return -1;
00735 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
00736 "Imode: %i, Invert: %i\n", status>>1, status&1);
00737
00738
00739 v->s.mv_table_index = get_bits(gb, 2);
00740 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
00741
00742 if (v->dquant)
00743 {
00744 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
00745 vop_dquant_decoding(v);
00746 }
00747
00748 v->ttfrm = 0;
00749 if (v->vstransform)
00750 {
00751 v->ttmbf = get_bits1(gb);
00752 if (v->ttmbf)
00753 {
00754 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
00755 }
00756 } else {
00757 v->ttmbf = 1;
00758 v->ttfrm = TT_8X8;
00759 }
00760 break;
00761 case FF_B_TYPE:
00762 if (v->pq < 5) v->tt_index = 0;
00763 else if(v->pq < 13) v->tt_index = 1;
00764 else v->tt_index = 2;
00765
00766 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
00767 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
00768 v->s.mspel = v->s.quarter_sample;
00769
00770 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
00771 if (status < 0) return -1;
00772 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
00773 "Imode: %i, Invert: %i\n", status>>1, status&1);
00774 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
00775 if (status < 0) return -1;
00776 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
00777 "Imode: %i, Invert: %i\n", status>>1, status&1);
00778
00779 v->s.mv_table_index = get_bits(gb, 2);
00780 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
00781
00782 if (v->dquant)
00783 {
00784 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
00785 vop_dquant_decoding(v);
00786 }
00787
00788 v->ttfrm = 0;
00789 if (v->vstransform)
00790 {
00791 v->ttmbf = get_bits1(gb);
00792 if (v->ttmbf)
00793 {
00794 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
00795 }
00796 } else {
00797 v->ttmbf = 1;
00798 v->ttfrm = TT_8X8;
00799 }
00800 break;
00801 }
00802
00803 if(!v->x8_type)
00804 {
00805
00806 v->c_ac_table_index = decode012(gb);
00807 if (v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE)
00808 {
00809 v->y_ac_table_index = decode012(gb);
00810 }
00811
00812 v->s.dc_table_index = get_bits1(gb);
00813 }
00814
00815 if(v->s.pict_type == FF_BI_TYPE) {
00816 v->s.pict_type = FF_B_TYPE;
00817 v->bi_type = 1;
00818 }
00819 return 0;
00820 }
00821
00822 int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
00823 {
00824 int pqindex, lowquant;
00825 int status;
00826
00827 v->p_frame_skipped = 0;
00828
00829 if(v->interlace){
00830 v->fcm = decode012(gb);
00831 if(v->fcm){
00832 if(!v->warn_interlaced++)
00833 av_log(v->s.avctx, AV_LOG_ERROR, "Interlaced frames/fields support is not implemented\n");
00834 return -1;
00835 }
00836 }
00837 switch(get_unary(gb, 0, 4)) {
00838 case 0:
00839 v->s.pict_type = FF_P_TYPE;
00840 break;
00841 case 1:
00842 v->s.pict_type = FF_B_TYPE;
00843 break;
00844 case 2:
00845 v->s.pict_type = FF_I_TYPE;
00846 break;
00847 case 3:
00848 v->s.pict_type = FF_BI_TYPE;
00849 break;
00850 case 4:
00851 v->s.pict_type = FF_P_TYPE;
00852 v->p_frame_skipped = 1;
00853 return 0;
00854 }
00855 if(v->tfcntrflag)
00856 skip_bits(gb, 8);
00857 if(v->broadcast) {
00858 if(!v->interlace || v->psf) {
00859 v->rptfrm = get_bits(gb, 2);
00860 } else {
00861 v->tff = get_bits1(gb);
00862 v->rptfrm = get_bits1(gb);
00863 }
00864 }
00865 if(v->panscanflag) {
00866
00867 }
00868 v->rnd = get_bits1(gb);
00869 if(v->interlace)
00870 v->uvsamp = get_bits1(gb);
00871 if(v->finterpflag) v->interpfrm = get_bits1(gb);
00872 if(v->s.pict_type == FF_B_TYPE) {
00873 v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
00874 v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
00875 if(v->bfraction == 0) {
00876 v->s.pict_type = FF_BI_TYPE;
00877 }
00878 }
00879 pqindex = get_bits(gb, 5);
00880 if(!pqindex) return -1;
00881 v->pqindex = pqindex;
00882 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00883 v->pq = ff_vc1_pquant_table[0][pqindex];
00884 else
00885 v->pq = ff_vc1_pquant_table[1][pqindex];
00886
00887 v->pquantizer = 1;
00888 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
00889 v->pquantizer = pqindex < 9;
00890 if (v->quantizer_mode == QUANT_NON_UNIFORM)
00891 v->pquantizer = 0;
00892 v->pqindex = pqindex;
00893 if (pqindex < 9) v->halfpq = get_bits1(gb);
00894 else v->halfpq = 0;
00895 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
00896 v->pquantizer = get_bits1(gb);
00897 if(v->postprocflag)
00898 v->postproc = get_bits(gb, 2);
00899
00900 if(v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_P_TYPE) v->use_ic = 0;
00901
00902 if(v->parse_only)
00903 return 0;
00904
00905 switch(v->s.pict_type) {
00906 case FF_I_TYPE:
00907 case FF_BI_TYPE:
00908 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
00909 if (status < 0) return -1;
00910 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
00911 "Imode: %i, Invert: %i\n", status>>1, status&1);
00912 v->condover = CONDOVER_NONE;
00913 if(v->overlap && v->pq <= 8) {
00914 v->condover = decode012(gb);
00915 if(v->condover == CONDOVER_SELECT) {
00916 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
00917 if (status < 0) return -1;
00918 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
00919 "Imode: %i, Invert: %i\n", status>>1, status&1);
00920 }
00921 }
00922 break;
00923 case FF_P_TYPE:
00924 if (v->extended_mv) v->mvrange = get_unary(gb, 0, 3);
00925 else v->mvrange = 0;
00926 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
00927 v->k_y = v->mvrange + 8;
00928 v->range_x = 1 << (v->k_x - 1);
00929 v->range_y = 1 << (v->k_y - 1);
00930
00931 if (v->pq < 5) v->tt_index = 0;
00932 else if(v->pq < 13) v->tt_index = 1;
00933 else v->tt_index = 2;
00934
00935 lowquant = (v->pq > 12) ? 0 : 1;
00936 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
00937 if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00938 {
00939 int scale, shift, i;
00940 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
00941 v->lumscale = get_bits(gb, 6);
00942 v->lumshift = get_bits(gb, 6);
00943
00944 if(!v->lumscale) {
00945 scale = -64;
00946 shift = (255 - v->lumshift * 2) << 6;
00947 if(v->lumshift > 31)
00948 shift += 128 << 6;
00949 } else {
00950 scale = v->lumscale + 32;
00951 if(v->lumshift > 31)
00952 shift = (v->lumshift - 64) << 6;
00953 else
00954 shift = v->lumshift << 6;
00955 }
00956 for(i = 0; i < 256; i++) {
00957 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
00958 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
00959 }
00960 v->use_ic = 1;
00961 }
00962 if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
00963 v->s.quarter_sample = 0;
00964 else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00965 if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
00966 v->s.quarter_sample = 0;
00967 else
00968 v->s.quarter_sample = 1;
00969 } else
00970 v->s.quarter_sample = 1;
00971 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));
00972
00973 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
00974 v->mv_mode2 == MV_PMODE_MIXED_MV)
00975 || v->mv_mode == MV_PMODE_MIXED_MV)
00976 {
00977 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
00978 if (status < 0) return -1;
00979 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
00980 "Imode: %i, Invert: %i\n", status>>1, status&1);
00981 } else {
00982 v->mv_type_is_raw = 0;
00983 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
00984 }
00985 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
00986 if (status < 0) return -1;
00987 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
00988 "Imode: %i, Invert: %i\n", status>>1, status&1);
00989
00990
00991 v->s.mv_table_index = get_bits(gb, 2);
00992 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
00993 if (v->dquant)
00994 {
00995 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
00996 vop_dquant_decoding(v);
00997 }
00998
00999 v->ttfrm = 0;
01000 if (v->vstransform)
01001 {
01002 v->ttmbf = get_bits1(gb);
01003 if (v->ttmbf)
01004 {
01005 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01006 }
01007 } else {
01008 v->ttmbf = 1;
01009 v->ttfrm = TT_8X8;
01010 }
01011 break;
01012 case FF_B_TYPE:
01013 if (v->extended_mv) v->mvrange = get_unary(gb, 0, 3);
01014 else v->mvrange = 0;
01015 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
01016 v->k_y = v->mvrange + 8;
01017 v->range_x = 1 << (v->k_x - 1);
01018 v->range_y = 1 << (v->k_y - 1);
01019
01020 if (v->pq < 5) v->tt_index = 0;
01021 else if(v->pq < 13) v->tt_index = 1;
01022 else v->tt_index = 2;
01023
01024 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
01025 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
01026 v->s.mspel = v->s.quarter_sample;
01027
01028 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
01029 if (status < 0) return -1;
01030 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
01031 "Imode: %i, Invert: %i\n", status>>1, status&1);
01032 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01033 if (status < 0) return -1;
01034 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01035 "Imode: %i, Invert: %i\n", status>>1, status&1);
01036
01037 v->s.mv_table_index = get_bits(gb, 2);
01038 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01039
01040 if (v->dquant)
01041 {
01042 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01043 vop_dquant_decoding(v);
01044 }
01045
01046 v->ttfrm = 0;
01047 if (v->vstransform)
01048 {
01049 v->ttmbf = get_bits1(gb);
01050 if (v->ttmbf)
01051 {
01052 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01053 }
01054 } else {
01055 v->ttmbf = 1;
01056 v->ttfrm = TT_8X8;
01057 }
01058 break;
01059 }
01060
01061
01062 v->c_ac_table_index = decode012(gb);
01063 if (v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE)
01064 {
01065 v->y_ac_table_index = decode012(gb);
01066 }
01067
01068 v->s.dc_table_index = get_bits1(gb);
01069 if ((v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE) && v->dquant) {
01070 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01071 vop_dquant_decoding(v);
01072 }
01073
01074 v->bi_type = 0;
01075 if(v->s.pict_type == FF_BI_TYPE) {
01076 v->s.pict_type = FF_B_TYPE;
01077 v->bi_type = 1;
01078 }
01079 return 0;
01080 }