00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00028 #include "dsputil.h"
00029 #include "avcodec.h"
00030 #include "mpegvideo.h"
00031 #include "vc1.h"
00032 #include "vc1data.h"
00033 #include "vc1acdata.h"
00034 #include "msmpeg4data.h"
00035 #include "unary.h"
00036 #include "simple_idct.h"
00037
00038 #undef NDEBUG
00039 #include <assert.h>
00040
00041 #define MB_INTRA_VLC_BITS 9
00042 #define DC_VLC_BITS 9
00043 #define AC_VLC_BITS 9
00044 static const uint16_t table_mb_intra[64][2];
00045
00046
00052 static int vc1_init_common(VC1Context *v)
00053 {
00054 static int done = 0;
00055 int i = 0;
00056
00057 v->hrd_rate = v->hrd_buffer = NULL;
00058
00059
00060 if(!done)
00061 {
00062 done = 1;
00063 init_vlc(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
00064 ff_vc1_bfraction_bits, 1, 1,
00065 ff_vc1_bfraction_codes, 1, 1, 1);
00066 init_vlc(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
00067 ff_vc1_norm2_bits, 1, 1,
00068 ff_vc1_norm2_codes, 1, 1, 1);
00069 init_vlc(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
00070 ff_vc1_norm6_bits, 1, 1,
00071 ff_vc1_norm6_codes, 2, 2, 1);
00072 init_vlc(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
00073 ff_vc1_imode_bits, 1, 1,
00074 ff_vc1_imode_codes, 1, 1, 1);
00075 for (i=0; i<3; i++)
00076 {
00077 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
00078 ff_vc1_ttmb_bits[i], 1, 1,
00079 ff_vc1_ttmb_codes[i], 2, 2, 1);
00080 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
00081 ff_vc1_ttblk_bits[i], 1, 1,
00082 ff_vc1_ttblk_codes[i], 1, 1, 1);
00083 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
00084 ff_vc1_subblkpat_bits[i], 1, 1,
00085 ff_vc1_subblkpat_codes[i], 1, 1, 1);
00086 }
00087 for(i=0; i<4; i++)
00088 {
00089 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
00090 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
00091 ff_vc1_4mv_block_pattern_codes[i], 1, 1, 1);
00092 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
00093 ff_vc1_cbpcy_p_bits[i], 1, 1,
00094 ff_vc1_cbpcy_p_codes[i], 2, 2, 1);
00095 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
00096 ff_vc1_mv_diff_bits[i], 1, 1,
00097 ff_vc1_mv_diff_codes[i], 2, 2, 1);
00098 }
00099 for(i=0; i<8; i++)
00100 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
00101 &vc1_ac_tables[i][0][1], 8, 4,
00102 &vc1_ac_tables[i][0][0], 8, 4, 1);
00103 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
00104 &ff_msmp4_mb_i_table[0][1], 4, 2,
00105 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
00106 }
00107
00108
00109 v->pq = -1;
00110 v->mvrange = 0;
00111
00112 return 0;
00113 }
00114
00115
00126 enum Imode {
00127 IMODE_RAW,
00128 IMODE_NORM2,
00129 IMODE_DIFF2,
00130 IMODE_NORM6,
00131 IMODE_DIFF6,
00132 IMODE_ROWSKIP,
00133 IMODE_COLSKIP
00134 };
00136
00143 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
00144 int x, y;
00145
00146 for (y=0; y<height; y++){
00147 if (!get_bits1(gb))
00148 memset(plane, 0, width);
00149 else
00150 for (x=0; x<width; x++)
00151 plane[x] = get_bits1(gb);
00152 plane += stride;
00153 }
00154 }
00155
00163 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
00164 int x, y;
00165
00166 for (x=0; x<width; x++){
00167 if (!get_bits1(gb))
00168 for (y=0; y<height; y++)
00169 plane[y*stride] = 0;
00170 else
00171 for (y=0; y<height; y++)
00172 plane[y*stride] = get_bits1(gb);
00173 plane ++;
00174 }
00175 }
00176
00183 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
00184 {
00185 GetBitContext *gb = &v->s.gb;
00186
00187 int imode, x, y, code, offset;
00188 uint8_t invert, *planep = data;
00189 int width, height, stride;
00190
00191 width = v->s.mb_width;
00192 height = v->s.mb_height;
00193 stride = v->s.mb_stride;
00194 invert = get_bits1(gb);
00195 imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
00196
00197 *raw_flag = 0;
00198 switch (imode)
00199 {
00200 case IMODE_RAW:
00201
00202 *raw_flag = 1;
00203 return invert;
00204 case IMODE_DIFF2:
00205 case IMODE_NORM2:
00206 if ((height * width) & 1)
00207 {
00208 *planep++ = get_bits1(gb);
00209 offset = 1;
00210 }
00211 else offset = 0;
00212
00213 for (y = offset; y < height * width; y += 2) {
00214 code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
00215 *planep++ = code & 1;
00216 offset++;
00217 if(offset == width) {
00218 offset = 0;
00219 planep += stride - width;
00220 }
00221 *planep++ = code >> 1;
00222 offset++;
00223 if(offset == width) {
00224 offset = 0;
00225 planep += stride - width;
00226 }
00227 }
00228 break;
00229 case IMODE_DIFF6:
00230 case IMODE_NORM6:
00231 if(!(height % 3) && (width % 3)) {
00232 for(y = 0; y < height; y+= 3) {
00233 for(x = width & 1; x < width; x += 2) {
00234 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
00235 if(code < 0){
00236 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
00237 return -1;
00238 }
00239 planep[x + 0] = (code >> 0) & 1;
00240 planep[x + 1] = (code >> 1) & 1;
00241 planep[x + 0 + stride] = (code >> 2) & 1;
00242 planep[x + 1 + stride] = (code >> 3) & 1;
00243 planep[x + 0 + stride * 2] = (code >> 4) & 1;
00244 planep[x + 1 + stride * 2] = (code >> 5) & 1;
00245 }
00246 planep += stride * 3;
00247 }
00248 if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
00249 } else {
00250 planep += (height & 1) * stride;
00251 for(y = height & 1; y < height; y += 2) {
00252 for(x = width % 3; x < width; x += 3) {
00253 code = get_vlc2(gb, ff_vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
00254 if(code < 0){
00255 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
00256 return -1;
00257 }
00258 planep[x + 0] = (code >> 0) & 1;
00259 planep[x + 1] = (code >> 1) & 1;
00260 planep[x + 2] = (code >> 2) & 1;
00261 planep[x + 0 + stride] = (code >> 3) & 1;
00262 planep[x + 1 + stride] = (code >> 4) & 1;
00263 planep[x + 2 + stride] = (code >> 5) & 1;
00264 }
00265 planep += stride * 2;
00266 }
00267 x = width % 3;
00268 if(x) decode_colskip(data , x, height , stride, &v->s.gb);
00269 if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
00270 }
00271 break;
00272 case IMODE_ROWSKIP:
00273 decode_rowskip(data, width, height, stride, &v->s.gb);
00274 break;
00275 case IMODE_COLSKIP:
00276 decode_colskip(data, width, height, stride, &v->s.gb);
00277 break;
00278 default: break;
00279 }
00280
00281
00282 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
00283 {
00284 planep = data;
00285 planep[0] ^= invert;
00286 for (x=1; x<width; x++)
00287 planep[x] ^= planep[x-1];
00288 for (y=1; y<height; y++)
00289 {
00290 planep += stride;
00291 planep[0] ^= planep[-stride];
00292 for (x=1; x<width; x++)
00293 {
00294 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
00295 else planep[x] ^= planep[x-1];
00296 }
00297 }
00298 }
00299 else if (invert)
00300 {
00301 planep = data;
00302 for (x=0; x<stride*height; x++) planep[x] = !planep[x];
00303 }
00304 return (imode<<1) + invert;
00305 }
00306
00308
00309
00313 static int vop_dquant_decoding(VC1Context *v)
00314 {
00315 GetBitContext *gb = &v->s.gb;
00316 int pqdiff;
00317
00318
00319 if (v->dquant == 2)
00320 {
00321 pqdiff = get_bits(gb, 3);
00322 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
00323 else v->altpq = v->pq + pqdiff + 1;
00324 }
00325 else
00326 {
00327 v->dquantfrm = get_bits1(gb);
00328 if ( v->dquantfrm )
00329 {
00330 v->dqprofile = get_bits(gb, 2);
00331 switch (v->dqprofile)
00332 {
00333 case DQPROFILE_SINGLE_EDGE:
00334 case DQPROFILE_DOUBLE_EDGES:
00335 v->dqsbedge = get_bits(gb, 2);
00336 break;
00337 case DQPROFILE_ALL_MBS:
00338 v->dqbilevel = get_bits1(gb);
00339 if(!v->dqbilevel)
00340 v->halfpq = 0;
00341 default: break;
00342 }
00343 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
00344 {
00345 pqdiff = get_bits(gb, 3);
00346 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
00347 else v->altpq = v->pq + pqdiff + 1;
00348 }
00349 }
00350 }
00351 return 0;
00352 }
00353
00356 static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
00357 {
00358 uint8_t *Y;
00359 int ys, us, vs;
00360 DSPContext *dsp = &v->s.dsp;
00361
00362 if(v->rangeredfrm) {
00363 int i, j, k;
00364 for(k = 0; k < 6; k++)
00365 for(j = 0; j < 8; j++)
00366 for(i = 0; i < 8; i++)
00367 block[k][i + j*8] = ((block[k][i + j*8] - 128) << 1) + 128;
00368
00369 }
00370 ys = v->s.current_picture.linesize[0];
00371 us = v->s.current_picture.linesize[1];
00372 vs = v->s.current_picture.linesize[2];
00373 Y = v->s.dest[0];
00374
00375 dsp->put_pixels_clamped(block[0], Y, ys);
00376 dsp->put_pixels_clamped(block[1], Y + 8, ys);
00377 Y += ys * 8;
00378 dsp->put_pixels_clamped(block[2], Y, ys);
00379 dsp->put_pixels_clamped(block[3], Y + 8, ys);
00380
00381 if(!(v->s.flags & CODEC_FLAG_GRAY)) {
00382 dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
00383 dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
00384 }
00385 }
00386
00390 static void vc1_mc_1mv(VC1Context *v, int dir)
00391 {
00392 MpegEncContext *s = &v->s;
00393 DSPContext *dsp = &v->s.dsp;
00394 uint8_t *srcY, *srcU, *srcV;
00395 int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
00396
00397 if(!v->s.last_picture.data[0])return;
00398
00399 mx = s->mv[dir][0][0];
00400 my = s->mv[dir][0][1];
00401
00402
00403 if(s->pict_type == P_TYPE) {
00404 s->current_picture.motion_val[1][s->block_index[0]][0] = mx;
00405 s->current_picture.motion_val[1][s->block_index[0]][1] = my;
00406 }
00407 uvmx = (mx + ((mx & 3) == 3)) >> 1;
00408 uvmy = (my + ((my & 3) == 3)) >> 1;
00409 if(v->fastuvmc) {
00410 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
00411 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
00412 }
00413 if(!dir) {
00414 srcY = s->last_picture.data[0];
00415 srcU = s->last_picture.data[1];
00416 srcV = s->last_picture.data[2];
00417 } else {
00418 srcY = s->next_picture.data[0];
00419 srcU = s->next_picture.data[1];
00420 srcV = s->next_picture.data[2];
00421 }
00422
00423 src_x = s->mb_x * 16 + (mx >> 2);
00424 src_y = s->mb_y * 16 + (my >> 2);
00425 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00426 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00427
00428 if(v->profile != PROFILE_ADVANCED){
00429 src_x = av_clip( src_x, -16, s->mb_width * 16);
00430 src_y = av_clip( src_y, -16, s->mb_height * 16);
00431 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
00432 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00433 }else{
00434 src_x = av_clip( src_x, -17, s->avctx->coded_width);
00435 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
00436 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
00437 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00438 }
00439
00440 srcY += src_y * s->linesize + src_x;
00441 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
00442 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
00443
00444
00445 if(s->flags & CODEC_FLAG_GRAY) {
00446 srcU = s->edge_emu_buffer + 18 * s->linesize;
00447 srcV = s->edge_emu_buffer + 18 * s->linesize;
00448 }
00449
00450 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00451 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
00452 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
00453 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
00454
00455 srcY -= s->mspel * (1 + s->linesize);
00456 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
00457 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
00458 srcY = s->edge_emu_buffer;
00459 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
00460 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00461 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
00462 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00463 srcU = uvbuf;
00464 srcV = uvbuf + 16;
00465
00466 if(v->rangeredfrm) {
00467 int i, j;
00468 uint8_t *src, *src2;
00469
00470 src = srcY;
00471 for(j = 0; j < 17 + s->mspel*2; j++) {
00472 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
00473 src += s->linesize;
00474 }
00475 src = srcU; src2 = srcV;
00476 for(j = 0; j < 9; j++) {
00477 for(i = 0; i < 9; i++) {
00478 src[i] = ((src[i] - 128) >> 1) + 128;
00479 src2[i] = ((src2[i] - 128) >> 1) + 128;
00480 }
00481 src += s->uvlinesize;
00482 src2 += s->uvlinesize;
00483 }
00484 }
00485
00486 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00487 int i, j;
00488 uint8_t *src, *src2;
00489
00490 src = srcY;
00491 for(j = 0; j < 17 + s->mspel*2; j++) {
00492 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
00493 src += s->linesize;
00494 }
00495 src = srcU; src2 = srcV;
00496 for(j = 0; j < 9; j++) {
00497 for(i = 0; i < 9; i++) {
00498 src[i] = v->lutuv[src[i]];
00499 src2[i] = v->lutuv[src2[i]];
00500 }
00501 src += s->uvlinesize;
00502 src2 += s->uvlinesize;
00503 }
00504 }
00505 srcY += s->mspel * (1 + s->linesize);
00506 }
00507
00508 if(s->mspel) {
00509 dxy = ((my & 3) << 2) | (mx & 3);
00510 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
00511 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
00512 srcY += s->linesize * 8;
00513 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
00514 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
00515 } else {
00516 dxy = (my & 2) | ((mx & 2) >> 1);
00517
00518 if(!v->rnd)
00519 dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00520 else
00521 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00522 }
00523
00524 if(s->flags & CODEC_FLAG_GRAY) return;
00525
00526 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
00527 uvmx = (uvmx&3)<<1;
00528 uvmy = (uvmy&3)<<1;
00529 if(!v->rnd){
00530 dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00531 dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00532 }else{
00533 dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00534 dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00535 }
00536 }
00537
00540 static void vc1_mc_4mv_luma(VC1Context *v, int n)
00541 {
00542 MpegEncContext *s = &v->s;
00543 DSPContext *dsp = &v->s.dsp;
00544 uint8_t *srcY;
00545 int dxy, mx, my, src_x, src_y;
00546 int off;
00547
00548 if(!v->s.last_picture.data[0])return;
00549 mx = s->mv[0][n][0];
00550 my = s->mv[0][n][1];
00551 srcY = s->last_picture.data[0];
00552
00553 off = s->linesize * 4 * (n&2) + (n&1) * 8;
00554
00555 src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
00556 src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
00557
00558 if(v->profile != PROFILE_ADVANCED){
00559 src_x = av_clip( src_x, -16, s->mb_width * 16);
00560 src_y = av_clip( src_y, -16, s->mb_height * 16);
00561 }else{
00562 src_x = av_clip( src_x, -17, s->avctx->coded_width);
00563 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
00564 }
00565
00566 srcY += src_y * s->linesize + src_x;
00567
00568 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00569 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
00570 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
00571 srcY -= s->mspel * (1 + s->linesize);
00572 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
00573 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
00574 srcY = s->edge_emu_buffer;
00575
00576 if(v->rangeredfrm) {
00577 int i, j;
00578 uint8_t *src;
00579
00580 src = srcY;
00581 for(j = 0; j < 9 + s->mspel*2; j++) {
00582 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
00583 src += s->linesize;
00584 }
00585 }
00586
00587 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00588 int i, j;
00589 uint8_t *src;
00590
00591 src = srcY;
00592 for(j = 0; j < 9 + s->mspel*2; j++) {
00593 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
00594 src += s->linesize;
00595 }
00596 }
00597 srcY += s->mspel * (1 + s->linesize);
00598 }
00599
00600 if(s->mspel) {
00601 dxy = ((my & 3) << 2) | (mx & 3);
00602 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
00603 } else {
00604 dxy = (my & 2) | ((mx & 2) >> 1);
00605 if(!v->rnd)
00606 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00607 else
00608 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00609 }
00610 }
00611
00612 static inline int median4(int a, int b, int c, int d)
00613 {
00614 if(a < b) {
00615 if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
00616 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
00617 } else {
00618 if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
00619 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
00620 }
00621 }
00622
00623
00626 static void vc1_mc_4mv_chroma(VC1Context *v)
00627 {
00628 MpegEncContext *s = &v->s;
00629 DSPContext *dsp = &v->s.dsp;
00630 uint8_t *srcU, *srcV;
00631 int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
00632 int i, idx, tx = 0, ty = 0;
00633 int mvx[4], mvy[4], intra[4];
00634 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
00635
00636 if(!v->s.last_picture.data[0])return;
00637 if(s->flags & CODEC_FLAG_GRAY) return;
00638
00639 for(i = 0; i < 4; i++) {
00640 mvx[i] = s->mv[0][i][0];
00641 mvy[i] = s->mv[0][i][1];
00642 intra[i] = v->mb_type[0][s->block_index[i]];
00643 }
00644
00645
00646 idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
00647 if(!idx) {
00648 tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
00649 ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
00650 } else if(count[idx] == 1) {
00651 switch(idx) {
00652 case 0x1:
00653 tx = mid_pred(mvx[1], mvx[2], mvx[3]);
00654 ty = mid_pred(mvy[1], mvy[2], mvy[3]);
00655 break;
00656 case 0x2:
00657 tx = mid_pred(mvx[0], mvx[2], mvx[3]);
00658 ty = mid_pred(mvy[0], mvy[2], mvy[3]);
00659 break;
00660 case 0x4:
00661 tx = mid_pred(mvx[0], mvx[1], mvx[3]);
00662 ty = mid_pred(mvy[0], mvy[1], mvy[3]);
00663 break;
00664 case 0x8:
00665 tx = mid_pred(mvx[0], mvx[1], mvx[2]);
00666 ty = mid_pred(mvy[0], mvy[1], mvy[2]);
00667 break;
00668 }
00669 } else if(count[idx] == 2) {
00670 int t1 = 0, t2 = 0;
00671 for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
00672 for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
00673 tx = (mvx[t1] + mvx[t2]) / 2;
00674 ty = (mvy[t1] + mvy[t2]) / 2;
00675 } else {
00676 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
00677 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
00678 return;
00679 }
00680
00681 s->current_picture.motion_val[1][s->block_index[0]][0] = tx;
00682 s->current_picture.motion_val[1][s->block_index[0]][1] = ty;
00683 uvmx = (tx + ((tx&3) == 3)) >> 1;
00684 uvmy = (ty + ((ty&3) == 3)) >> 1;
00685 if(v->fastuvmc) {
00686 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
00687 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
00688 }
00689
00690 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00691 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00692
00693 if(v->profile != PROFILE_ADVANCED){
00694 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
00695 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00696 }else{
00697 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
00698 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00699 }
00700
00701 srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00702 srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00703 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00704 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
00705 || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
00706 ff_emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize, 8+1, 8+1,
00707 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00708 ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
00709 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00710 srcU = s->edge_emu_buffer;
00711 srcV = s->edge_emu_buffer + 16;
00712
00713
00714 if(v->rangeredfrm) {
00715 int i, j;
00716 uint8_t *src, *src2;
00717
00718 src = srcU; src2 = srcV;
00719 for(j = 0; j < 9; j++) {
00720 for(i = 0; i < 9; i++) {
00721 src[i] = ((src[i] - 128) >> 1) + 128;
00722 src2[i] = ((src2[i] - 128) >> 1) + 128;
00723 }
00724 src += s->uvlinesize;
00725 src2 += s->uvlinesize;
00726 }
00727 }
00728
00729 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00730 int i, j;
00731 uint8_t *src, *src2;
00732
00733 src = srcU; src2 = srcV;
00734 for(j = 0; j < 9; j++) {
00735 for(i = 0; i < 9; i++) {
00736 src[i] = v->lutuv[src[i]];
00737 src2[i] = v->lutuv[src2[i]];
00738 }
00739 src += s->uvlinesize;
00740 src2 += s->uvlinesize;
00741 }
00742 }
00743 }
00744
00745
00746 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
00747 uvmx = (uvmx&3)<<1;
00748 uvmy = (uvmy&3)<<1;
00749 if(!v->rnd){
00750 dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00751 dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00752 }else{
00753 dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00754 dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00755 }
00756 }
00757
00758 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
00759
00767 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
00768 {
00769 VC1Context *v = avctx->priv_data;
00770
00771 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
00772 v->profile = get_bits(gb, 2);
00773 if (v->profile == PROFILE_COMPLEX)
00774 {
00775 av_log(avctx, AV_LOG_ERROR, "WMV3 Complex Profile is not fully supported\n");
00776 }
00777
00778 if (v->profile == PROFILE_ADVANCED)
00779 {
00780 v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
00781 v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
00782 return decode_sequence_header_adv(v, gb);
00783 }
00784 else
00785 {
00786 v->zz_8x4 = ff_vc1_simple_progressive_8x4_zz;
00787 v->zz_4x8 = ff_vc1_simple_progressive_4x8_zz;
00788 v->res_sm = get_bits(gb, 2);
00789 if (v->res_sm)
00790 {
00791 av_log(avctx, AV_LOG_ERROR,
00792 "Reserved RES_SM=%i is forbidden\n", v->res_sm);
00793 return -1;
00794 }
00795 }
00796
00797
00798 v->frmrtq_postproc = get_bits(gb, 3);
00799
00800 v->bitrtq_postproc = get_bits(gb, 5);
00801 v->s.loop_filter = get_bits1(gb);
00802 if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
00803 {
00804 av_log(avctx, AV_LOG_ERROR,
00805 "LOOPFILTER shell not be enabled in simple profile\n");
00806 }
00807
00808 v->res_x8 = get_bits1(gb);
00809 v->multires = get_bits1(gb);
00810 v->res_fasttx = get_bits1(gb);
00811 if (!v->res_fasttx)
00812 {
00813 v->s.dsp.vc1_inv_trans_8x8 = ff_simple_idct;
00814 v->s.dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
00815 v->s.dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
00816 v->s.dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
00817 }
00818
00819 v->fastuvmc = get_bits1(gb);
00820 if (!v->profile && !v->fastuvmc)
00821 {
00822 av_log(avctx, AV_LOG_ERROR,
00823 "FASTUVMC unavailable in Simple Profile\n");
00824 return -1;
00825 }
00826 v->extended_mv = get_bits1(gb);
00827 if (!v->profile && v->extended_mv)
00828 {
00829 av_log(avctx, AV_LOG_ERROR,
00830 "Extended MVs unavailable in Simple Profile\n");
00831 return -1;
00832 }
00833 v->dquant = get_bits(gb, 2);
00834 v->vstransform = get_bits1(gb);
00835
00836 v->res_transtab = get_bits1(gb);
00837 if (v->res_transtab)
00838 {
00839 av_log(avctx, AV_LOG_ERROR,
00840 "1 for reserved RES_TRANSTAB is forbidden\n");
00841 return -1;
00842 }
00843
00844 v->overlap = get_bits1(gb);
00845
00846 v->s.resync_marker = get_bits1(gb);
00847 v->rangered = get_bits1(gb);
00848 if (v->rangered && v->profile == PROFILE_SIMPLE)
00849 {
00850 av_log(avctx, AV_LOG_INFO,
00851 "RANGERED should be set to 0 in simple profile\n");
00852 }
00853
00854 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3);
00855 v->quantizer_mode = get_bits(gb, 2);
00856
00857 v->finterpflag = get_bits1(gb);
00858 v->res_rtm_flag = get_bits1(gb);
00859 if (!v->res_rtm_flag)
00860 {
00861
00862
00863 av_log(avctx, AV_LOG_ERROR,
00864 "Old WMV3 version detected, only I-frames will be decoded\n");
00865
00866 }
00867
00868 if(!v->res_fasttx) skip_bits(gb, 16);
00869 av_log(avctx, AV_LOG_DEBUG,
00870 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
00871 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
00872 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
00873 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
00874 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
00875 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
00876 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
00877 v->dquant, v->quantizer_mode, avctx->max_b_frames
00878 );
00879 return 0;
00880 }
00881
00882 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
00883 {
00884 v->res_rtm_flag = 1;
00885 v->level = get_bits(gb, 3);
00886 if(v->level >= 5)
00887 {
00888 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
00889 }
00890 v->chromaformat = get_bits(gb, 2);
00891 if (v->chromaformat != 1)
00892 {
00893 av_log(v->s.avctx, AV_LOG_ERROR,
00894 "Only 4:2:0 chroma format supported\n");
00895 return -1;
00896 }
00897
00898
00899 v->frmrtq_postproc = get_bits(gb, 3);
00900
00901 v->bitrtq_postproc = get_bits(gb, 5);
00902 v->postprocflag = get_bits1(gb);
00903
00904 v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
00905 v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
00906 v->s.avctx->width = v->s.avctx->coded_width;
00907 v->s.avctx->height = v->s.avctx->coded_height;
00908 v->broadcast = get_bits1(gb);
00909 v->interlace = get_bits1(gb);
00910 v->tfcntrflag = get_bits1(gb);
00911 v->finterpflag = get_bits1(gb);
00912 skip_bits1(gb);
00913
00914 v->s.h_edge_pos = v->s.avctx->coded_width;
00915 v->s.v_edge_pos = v->s.avctx->coded_height;
00916
00917 av_log(v->s.avctx, AV_LOG_DEBUG,
00918 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
00919 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
00920 "TFCTRflag=%i, FINTERPflag=%i\n",
00921 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
00922 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
00923 v->tfcntrflag, v->finterpflag
00924 );
00925
00926 v->psf = get_bits1(gb);
00927 if(v->psf) {
00928 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
00929 return -1;
00930 }
00931 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
00932 if(get_bits1(gb)) {
00933 int w, h, ar = 0;
00934 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
00935 v->s.avctx->width = v->s.width = w = get_bits(gb, 14) + 1;
00936 v->s.avctx->height = v->s.height = h = get_bits(gb, 14) + 1;
00937 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
00938 if(get_bits1(gb))
00939 ar = get_bits(gb, 4);
00940 if(ar && ar < 14){
00941 v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];
00942 }else if(ar == 15){
00943 w = get_bits(gb, 8);
00944 h = get_bits(gb, 8);
00945 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
00946 }
00947
00948 if(get_bits1(gb)){
00949 if(get_bits1(gb)) {
00950 v->s.avctx->time_base.num = 32;
00951 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
00952 } else {
00953 int nr, dr;
00954 nr = get_bits(gb, 8);
00955 dr = get_bits(gb, 4);
00956 if(nr && nr < 8 && dr && dr < 3){
00957 v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
00958 v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
00959 }
00960 }
00961 }
00962
00963 if(get_bits1(gb)){
00964 v->color_prim = get_bits(gb, 8);
00965 v->transfer_char = get_bits(gb, 8);
00966 v->matrix_coef = get_bits(gb, 8);
00967 }
00968 }
00969
00970 v->hrd_param_flag = get_bits1(gb);
00971 if(v->hrd_param_flag) {
00972 int i;
00973 v->hrd_num_leaky_buckets = get_bits(gb, 5);
00974 skip_bits(gb, 4);
00975 skip_bits(gb, 4);
00976 for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
00977 skip_bits(gb, 16);
00978 skip_bits(gb, 16);
00979 }
00980 }
00981 return 0;
00982 }
00983
00984 static int decode_entry_point(AVCodecContext *avctx, GetBitContext *gb)
00985 {
00986 VC1Context *v = avctx->priv_data;
00987 int i, blink, clentry, refdist;
00988
00989 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
00990 blink = get_bits1(gb);
00991 clentry = get_bits1(gb);
00992 v->panscanflag = get_bits1(gb);
00993 refdist = get_bits1(gb);
00994 v->s.loop_filter = get_bits1(gb);
00995 v->fastuvmc = get_bits1(gb);
00996 v->extended_mv = get_bits1(gb);
00997 v->dquant = get_bits(gb, 2);
00998 v->vstransform = get_bits1(gb);
00999 v->overlap = get_bits1(gb);
01000 v->quantizer_mode = get_bits(gb, 2);
01001
01002 if(v->hrd_param_flag){
01003 for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
01004 skip_bits(gb, 8);
01005 }
01006 }
01007
01008 if(get_bits1(gb)){
01009 avctx->coded_width = (get_bits(gb, 12)+1)<<1;
01010 avctx->coded_height = (get_bits(gb, 12)+1)<<1;
01011 }
01012 if(v->extended_mv)
01013 v->extended_dmv = get_bits1(gb);
01014 if(get_bits1(gb)) {
01015 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
01016 skip_bits(gb, 3);
01017 }
01018 if(get_bits1(gb)) {
01019 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
01020 skip_bits(gb, 3);
01021 }
01022
01023 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
01024 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
01025 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
01026 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
01027 blink, clentry, v->panscanflag, refdist, v->s.loop_filter,
01028 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
01029
01030 return 0;
01031 }
01032
01033 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
01034 {
01035 int pqindex, lowquant, status;
01036
01037 if(v->finterpflag) v->interpfrm = get_bits1(gb);
01038 skip_bits(gb, 2);
01039 v->rangeredfrm = 0;
01040 if (v->rangered) v->rangeredfrm = get_bits1(gb);
01041 v->s.pict_type = get_bits1(gb);
01042 if (v->s.avctx->max_b_frames) {
01043 if (!v->s.pict_type) {
01044 if (get_bits1(gb)) v->s.pict_type = I_TYPE;
01045 else v->s.pict_type = B_TYPE;
01046 } else v->s.pict_type = P_TYPE;
01047 } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
01048
01049 v->bi_type = 0;
01050 if(v->s.pict_type == B_TYPE) {
01051 v->bfraction = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
01052 v->bfraction = ff_vc1_bfraction_lut[v->bfraction];
01053 if(v->bfraction == 0) {
01054 v->s.pict_type = BI_TYPE;
01055 }
01056 }
01057 if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
01058 skip_bits(gb, 7);
01059
01060
01061 if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
01062 v->rnd = 1;
01063 if(v->s.pict_type == P_TYPE)
01064 v->rnd ^= 1;
01065
01066
01067 pqindex = get_bits(gb, 5);
01068 if(!pqindex) return -1;
01069 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
01070 v->pq = ff_vc1_pquant_table[0][pqindex];
01071 else
01072 v->pq = ff_vc1_pquant_table[1][pqindex];
01073
01074 v->pquantizer = 1;
01075 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
01076 v->pquantizer = pqindex < 9;
01077 if (v->quantizer_mode == QUANT_NON_UNIFORM)
01078 v->pquantizer = 0;
01079 v->pqindex = pqindex;
01080 if (pqindex < 9) v->halfpq = get_bits1(gb);
01081 else v->halfpq = 0;
01082 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
01083 v->pquantizer = get_bits1(gb);
01084 v->dquantfrm = 0;
01085 if (v->extended_mv == 1) v->mvrange = get_unary(gb, 0, 3);
01086 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
01087 v->k_y = v->mvrange + 8;
01088 v->range_x = 1 << (v->k_x - 1);
01089 v->range_y = 1 << (v->k_y - 1);
01090 if (v->profile == PROFILE_ADVANCED)
01091 {
01092 if (v->postprocflag) v->postproc = get_bits1(gb);
01093 }
01094 else
01095 if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
01096
01097 if(v->res_x8 && (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)){
01098 v->x8_type = get_bits1(gb);
01099 }else v->x8_type = 0;
01100
01101
01102
01103 if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
01104
01105 switch(v->s.pict_type) {
01106 case P_TYPE:
01107 if (v->pq < 5) v->tt_index = 0;
01108 else if(v->pq < 13) v->tt_index = 1;
01109 else v->tt_index = 2;
01110
01111 lowquant = (v->pq > 12) ? 0 : 1;
01112 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
01113 if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
01114 {
01115 int scale, shift, i;
01116 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
01117 v->lumscale = get_bits(gb, 6);
01118 v->lumshift = get_bits(gb, 6);
01119 v->use_ic = 1;
01120
01121 if(!v->lumscale) {
01122 scale = -64;
01123 shift = (255 - v->lumshift * 2) << 6;
01124 if(v->lumshift > 31)
01125 shift += 128 << 6;
01126 } else {
01127 scale = v->lumscale + 32;
01128 if(v->lumshift > 31)
01129 shift = (v->lumshift - 64) << 6;
01130 else
01131 shift = v->lumshift << 6;
01132 }
01133 for(i = 0; i < 256; i++) {
01134 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
01135 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
01136 }
01137 }
01138 if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
01139 v->s.quarter_sample = 0;
01140 else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01141 if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
01142 v->s.quarter_sample = 0;
01143 else
01144 v->s.quarter_sample = 1;
01145 } else
01146 v->s.quarter_sample = 1;
01147 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));
01148
01149 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01150 v->mv_mode2 == MV_PMODE_MIXED_MV)
01151 || v->mv_mode == MV_PMODE_MIXED_MV)
01152 {
01153 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
01154 if (status < 0) return -1;
01155 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
01156 "Imode: %i, Invert: %i\n", status>>1, status&1);
01157 } else {
01158 v->mv_type_is_raw = 0;
01159 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
01160 }
01161 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01162 if (status < 0) return -1;
01163 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01164 "Imode: %i, Invert: %i\n", status>>1, status&1);
01165
01166
01167 v->s.mv_table_index = get_bits(gb, 2);
01168 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01169
01170 if (v->dquant)
01171 {
01172 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01173 vop_dquant_decoding(v);
01174 }
01175
01176 v->ttfrm = 0;
01177 if (v->vstransform)
01178 {
01179 v->ttmbf = get_bits1(gb);
01180 if (v->ttmbf)
01181 {
01182 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01183 }
01184 } else {
01185 v->ttmbf = 1;
01186 v->ttfrm = TT_8X8;
01187 }
01188 break;
01189 case B_TYPE:
01190 if (v->pq < 5) v->tt_index = 0;
01191 else if(v->pq < 13) v->tt_index = 1;
01192 else v->tt_index = 2;
01193
01194 lowquant = (v->pq > 12) ? 0 : 1;
01195 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
01196 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
01197 v->s.mspel = v->s.quarter_sample;
01198
01199 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
01200 if (status < 0) return -1;
01201 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
01202 "Imode: %i, Invert: %i\n", status>>1, status&1);
01203 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01204 if (status < 0) return -1;
01205 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01206 "Imode: %i, Invert: %i\n", status>>1, status&1);
01207
01208 v->s.mv_table_index = get_bits(gb, 2);
01209 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01210
01211 if (v->dquant)
01212 {
01213 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01214 vop_dquant_decoding(v);
01215 }
01216
01217 v->ttfrm = 0;
01218 if (v->vstransform)
01219 {
01220 v->ttmbf = get_bits1(gb);
01221 if (v->ttmbf)
01222 {
01223 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01224 }
01225 } else {
01226 v->ttmbf = 1;
01227 v->ttfrm = TT_8X8;
01228 }
01229 break;
01230 }
01231
01232 if(!v->x8_type)
01233 {
01234
01235 v->c_ac_table_index = decode012(gb);
01236 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
01237 {
01238 v->y_ac_table_index = decode012(gb);
01239 }
01240
01241 v->s.dc_table_index = get_bits1(gb);
01242 }
01243
01244 if(v->s.pict_type == BI_TYPE) {
01245 v->s.pict_type = B_TYPE;
01246 v->bi_type = 1;
01247 }
01248 return 0;
01249 }
01250
01251 static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
01252 {
01253 int pqindex, lowquant;
01254 int status;
01255
01256 v->p_frame_skipped = 0;
01257
01258 if(v->interlace){
01259 v->fcm = decode012(gb);
01260 if(v->fcm) return -1;
01261 }
01262 switch(get_unary(gb, 0, 4)) {
01263 case 0:
01264 v->s.pict_type = P_TYPE;
01265 break;
01266 case 1:
01267 v->s.pict_type = B_TYPE;
01268 break;
01269 case 2:
01270 v->s.pict_type = I_TYPE;
01271 break;
01272 case 3:
01273 v->s.pict_type = BI_TYPE;
01274 break;
01275 case 4:
01276 v->s.pict_type = P_TYPE;
01277 v->p_frame_skipped = 1;
01278 return 0;
01279 }
01280 if(v->tfcntrflag)
01281 skip_bits(gb, 8);
01282 if(v->broadcast) {
01283 if(!v->interlace || v->psf) {
01284 v->rptfrm = get_bits(gb, 2);
01285 } else {
01286 v->tff = get_bits1(gb);
01287 v->rptfrm = get_bits1(gb);
01288 }
01289 }
01290 if(v->panscanflag) {
01291
01292 }
01293 v->rnd = get_bits1(gb);
01294 if(v->interlace)
01295 v->uvsamp = get_bits1(gb);
01296 if(v->finterpflag) v->interpfrm = get_bits1(gb);
01297 if(v->s.pict_type == B_TYPE) {
01298 v->bfraction = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
01299 v->bfraction = ff_vc1_bfraction_lut[v->bfraction];
01300 if(v->bfraction == 0) {
01301 v->s.pict_type = BI_TYPE;
01302 }
01303 }
01304 pqindex = get_bits(gb, 5);
01305 if(!pqindex) return -1;
01306 v->pqindex = pqindex;
01307 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
01308 v->pq = ff_vc1_pquant_table[0][pqindex];
01309 else
01310 v->pq = ff_vc1_pquant_table[1][pqindex];
01311
01312 v->pquantizer = 1;
01313 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
01314 v->pquantizer = pqindex < 9;
01315 if (v->quantizer_mode == QUANT_NON_UNIFORM)
01316 v->pquantizer = 0;
01317 v->pqindex = pqindex;
01318 if (pqindex < 9) v->halfpq = get_bits1(gb);
01319 else v->halfpq = 0;
01320 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
01321 v->pquantizer = get_bits1(gb);
01322
01323 if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
01324
01325 switch(v->s.pict_type) {
01326 case I_TYPE:
01327 case BI_TYPE:
01328 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
01329 if (status < 0) return -1;
01330 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
01331 "Imode: %i, Invert: %i\n", status>>1, status&1);
01332 v->condover = CONDOVER_NONE;
01333 if(v->overlap && v->pq <= 8) {
01334 v->condover = decode012(gb);
01335 if(v->condover == CONDOVER_SELECT) {
01336 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
01337 if (status < 0) return -1;
01338 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
01339 "Imode: %i, Invert: %i\n", status>>1, status&1);
01340 }
01341 }
01342 break;
01343 case P_TYPE:
01344 if(v->postprocflag)
01345 v->postproc = get_bits1(gb);
01346 if (v->extended_mv) v->mvrange = get_unary(gb, 0, 3);
01347 else v->mvrange = 0;
01348 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
01349 v->k_y = v->mvrange + 8;
01350 v->range_x = 1 << (v->k_x - 1);
01351 v->range_y = 1 << (v->k_y - 1);
01352
01353 if (v->pq < 5) v->tt_index = 0;
01354 else if(v->pq < 13) v->tt_index = 1;
01355 else v->tt_index = 2;
01356
01357 lowquant = (v->pq > 12) ? 0 : 1;
01358 v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
01359 if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
01360 {
01361 int scale, shift, i;
01362 v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
01363 v->lumscale = get_bits(gb, 6);
01364 v->lumshift = get_bits(gb, 6);
01365
01366 if(!v->lumscale) {
01367 scale = -64;
01368 shift = (255 - v->lumshift * 2) << 6;
01369 if(v->lumshift > 31)
01370 shift += 128 << 6;
01371 } else {
01372 scale = v->lumscale + 32;
01373 if(v->lumshift > 31)
01374 shift = (v->lumshift - 64) << 6;
01375 else
01376 shift = v->lumshift << 6;
01377 }
01378 for(i = 0; i < 256; i++) {
01379 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
01380 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
01381 }
01382 v->use_ic = 1;
01383 }
01384 if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
01385 v->s.quarter_sample = 0;
01386 else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01387 if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
01388 v->s.quarter_sample = 0;
01389 else
01390 v->s.quarter_sample = 1;
01391 } else
01392 v->s.quarter_sample = 1;
01393 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));
01394
01395 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
01396 v->mv_mode2 == MV_PMODE_MIXED_MV)
01397 || v->mv_mode == MV_PMODE_MIXED_MV)
01398 {
01399 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
01400 if (status < 0) return -1;
01401 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
01402 "Imode: %i, Invert: %i\n", status>>1, status&1);
01403 } else {
01404 v->mv_type_is_raw = 0;
01405 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
01406 }
01407 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01408 if (status < 0) return -1;
01409 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01410 "Imode: %i, Invert: %i\n", status>>1, status&1);
01411
01412
01413 v->s.mv_table_index = get_bits(gb, 2);
01414 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01415 if (v->dquant)
01416 {
01417 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01418 vop_dquant_decoding(v);
01419 }
01420
01421 v->ttfrm = 0;
01422 if (v->vstransform)
01423 {
01424 v->ttmbf = get_bits1(gb);
01425 if (v->ttmbf)
01426 {
01427 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01428 }
01429 } else {
01430 v->ttmbf = 1;
01431 v->ttfrm = TT_8X8;
01432 }
01433 break;
01434 case B_TYPE:
01435 if(v->postprocflag)
01436 v->postproc = get_bits1(gb);
01437 if (v->extended_mv) v->mvrange = get_unary(gb, 0, 3);
01438 else v->mvrange = 0;
01439 v->k_x = v->mvrange + 9 + (v->mvrange >> 1);
01440 v->k_y = v->mvrange + 8;
01441 v->range_x = 1 << (v->k_x - 1);
01442 v->range_y = 1 << (v->k_y - 1);
01443
01444 if (v->pq < 5) v->tt_index = 0;
01445 else if(v->pq < 13) v->tt_index = 1;
01446 else v->tt_index = 2;
01447
01448 lowquant = (v->pq > 12) ? 0 : 1;
01449 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
01450 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
01451 v->s.mspel = v->s.quarter_sample;
01452
01453 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
01454 if (status < 0) return -1;
01455 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
01456 "Imode: %i, Invert: %i\n", status>>1, status&1);
01457 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
01458 if (status < 0) return -1;
01459 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
01460 "Imode: %i, Invert: %i\n", status>>1, status&1);
01461
01462 v->s.mv_table_index = get_bits(gb, 2);
01463 v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
01464
01465 if (v->dquant)
01466 {
01467 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01468 vop_dquant_decoding(v);
01469 }
01470
01471 v->ttfrm = 0;
01472 if (v->vstransform)
01473 {
01474 v->ttmbf = get_bits1(gb);
01475 if (v->ttmbf)
01476 {
01477 v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
01478 }
01479 } else {
01480 v->ttmbf = 1;
01481 v->ttfrm = TT_8X8;
01482 }
01483 break;
01484 }
01485
01486
01487 v->c_ac_table_index = decode012(gb);
01488 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
01489 {
01490 v->y_ac_table_index = decode012(gb);
01491 }
01492
01493 v->s.dc_table_index = get_bits1(gb);
01494 if ((v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE) && v->dquant) {
01495 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
01496 vop_dquant_decoding(v);
01497 }
01498
01499 v->bi_type = 0;
01500 if(v->s.pict_type == BI_TYPE) {
01501 v->s.pict_type = B_TYPE;
01502 v->bi_type = 1;
01503 }
01504 return 0;
01505 }
01506
01507
01518 #define GET_MQUANT() \
01519 if (v->dquantfrm) \
01520 { \
01521 int edges = 0; \
01522 if (v->dqprofile == DQPROFILE_ALL_MBS) \
01523 { \
01524 if (v->dqbilevel) \
01525 { \
01526 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
01527 } \
01528 else \
01529 { \
01530 mqdiff = get_bits(gb, 3); \
01531 if (mqdiff != 7) mquant = v->pq + mqdiff; \
01532 else mquant = get_bits(gb, 5); \
01533 } \
01534 } \
01535 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
01536 edges = 1 << v->dqsbedge; \
01537 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
01538 edges = (3 << v->dqsbedge) % 15; \
01539 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
01540 edges = 15; \
01541 if((edges&1) && !s->mb_x) \
01542 mquant = v->altpq; \
01543 if((edges&2) && s->first_slice_line) \
01544 mquant = v->altpq; \
01545 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
01546 mquant = v->altpq; \
01547 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
01548 mquant = v->altpq; \
01549 }
01550
01558 #define GET_MVDATA(_dmv_x, _dmv_y) \
01559 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table,\
01560 VC1_MV_DIFF_VLC_BITS, 2); \
01561 if (index > 36) \
01562 { \
01563 mb_has_coeffs = 1; \
01564 index -= 37; \
01565 } \
01566 else mb_has_coeffs = 0; \
01567 s->mb_intra = 0; \
01568 if (!index) { _dmv_x = _dmv_y = 0; } \
01569 else if (index == 35) \
01570 { \
01571 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
01572 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
01573 } \
01574 else if (index == 36) \
01575 { \
01576 _dmv_x = 0; \
01577 _dmv_y = 0; \
01578 s->mb_intra = 1; \
01579 } \
01580 else \
01581 { \
01582 index1 = index%6; \
01583 if (!s->quarter_sample && index1 == 5) val = 1; \
01584 else val = 0; \
01585 if(size_table[index1] - val > 0) \
01586 val = get_bits(gb, size_table[index1] - val); \
01587 else val = 0; \
01588 sign = 0 - (val&1); \
01589 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
01590 \
01591 index1 = index/6; \
01592 if (!s->quarter_sample && index1 == 5) val = 1; \
01593 else val = 0; \
01594 if(size_table[index1] - val > 0) \
01595 val = get_bits(gb, size_table[index1] - val); \
01596 else val = 0; \
01597 sign = 0 - (val&1); \
01598 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
01599 }
01600
01603 static inline void vc1_pred_mv(MpegEncContext *s, int n, int dmv_x, int dmv_y, int mv1, int r_x, int r_y, uint8_t* is_intra)
01604 {
01605 int xy, wrap, off = 0;
01606 int16_t *A, *B, *C;
01607 int px, py;
01608 int sum;
01609
01610
01611 dmv_x <<= 1 - s->quarter_sample;
01612 dmv_y <<= 1 - s->quarter_sample;
01613
01614 wrap = s->b8_stride;
01615 xy = s->block_index[n];
01616
01617 if(s->mb_intra){
01618 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
01619 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
01620 s->current_picture.motion_val[1][xy][0] = 0;
01621 s->current_picture.motion_val[1][xy][1] = 0;
01622 if(mv1) {
01623 s->current_picture.motion_val[0][xy + 1][0] = 0;
01624 s->current_picture.motion_val[0][xy + 1][1] = 0;
01625 s->current_picture.motion_val[0][xy + wrap][0] = 0;
01626 s->current_picture.motion_val[0][xy + wrap][1] = 0;
01627 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
01628 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
01629 s->current_picture.motion_val[1][xy + 1][0] = 0;
01630 s->current_picture.motion_val[1][xy + 1][1] = 0;
01631 s->current_picture.motion_val[1][xy + wrap][0] = 0;
01632 s->current_picture.motion_val[1][xy + wrap][1] = 0;
01633 s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
01634 s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
01635 }
01636 return;
01637 }
01638
01639 C = s->current_picture.motion_val[0][xy - 1];
01640 A = s->current_picture.motion_val[0][xy - wrap];
01641 if(mv1)
01642 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
01643 else {
01644
01645 switch(n){
01646 case 0:
01647 off = (s->mb_x > 0) ? -1 : 1;
01648 break;
01649 case 1:
01650 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
01651 break;
01652 case 2:
01653 off = 1;
01654 break;
01655 case 3:
01656 off = -1;
01657 }
01658 }
01659 B = s->current_picture.motion_val[0][xy - wrap + off];
01660
01661 if(!s->first_slice_line || (n==2 || n==3)) {
01662 if(s->mb_width == 1) {
01663 px = A[0];
01664 py = A[1];
01665 } else {
01666 px = mid_pred(A[0], B[0], C[0]);
01667 py = mid_pred(A[1], B[1], C[1]);
01668 }
01669 } else if(s->mb_x || (n==1 || n==3)) {
01670 px = C[0];
01671 py = C[1];
01672 } else {
01673 px = py = 0;
01674 }
01675
01676 {
01677 int qx, qy, X, Y;
01678 qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
01679 qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
01680 X = (s->mb_width << 6) - 4;
01681 Y = (s->mb_height << 6) - 4;
01682 if(mv1) {
01683 if(qx + px < -60) px = -60 - qx;
01684 if(qy + py < -60) py = -60 - qy;
01685 } else {
01686 if(qx + px < -28) px = -28 - qx;
01687 if(qy + py < -28) py = -28 - qy;
01688 }
01689 if(qx + px > X) px = X - qx;
01690 if(qy + py > Y) py = Y - qy;
01691 }
01692
01693 if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
01694 if(is_intra[xy - wrap])
01695 sum = FFABS(px) + FFABS(py);
01696 else
01697 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
01698 if(sum > 32) {
01699 if(get_bits1(&s->gb)) {
01700 px = A[0];
01701 py = A[1];
01702 } else {
01703 px = C[0];
01704 py = C[1];
01705 }
01706 } else {
01707 if(is_intra[xy - 1])
01708 sum = FFABS(px) + FFABS(py);
01709 else
01710 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
01711 if(sum > 32) {
01712 if(get_bits1(&s->gb)) {
01713 px = A[0];
01714 py = A[1];
01715 } else {
01716 px = C[0];
01717 py = C[1];
01718 }
01719 }
01720 }
01721 }
01722
01723 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
01724 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
01725 if(mv1) {
01726 s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
01727 s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
01728 s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
01729 s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
01730 s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
01731 s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
01732 }
01733 }
01734
01737 static void vc1_interp_mc(VC1Context *v)
01738 {
01739 MpegEncContext *s = &v->s;
01740 DSPContext *dsp = &v->s.dsp;
01741 uint8_t *srcY, *srcU, *srcV;
01742 int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
01743
01744 if(!v->s.next_picture.data[0])return;
01745
01746 mx = s->mv[1][0][0];
01747 my = s->mv[1][0][1];
01748 uvmx = (mx + ((mx & 3) == 3)) >> 1;
01749 uvmy = (my + ((my & 3) == 3)) >> 1;
01750 if(v->fastuvmc) {
01751 uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
01752 uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
01753 }
01754 srcY = s->next_picture.data[0];
01755 srcU = s->next_picture.data[1];
01756 srcV = s->next_picture.data[2];
01757
01758 src_x = s->mb_x * 16 + (mx >> 2);
01759 src_y = s->mb_y * 16 + (my >> 2);
01760 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
01761 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
01762
01763 if(v->profile != PROFILE_ADVANCED){
01764 src_x = av_clip( src_x, -16, s->mb_width * 16);
01765 src_y = av_clip( src_y, -16, s->mb_height * 16);
01766 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
01767 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
01768 }else{
01769 src_x = av_clip( src_x, -17, s->avctx->coded_width);
01770 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
01771 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
01772 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
01773 }
01774
01775 srcY += src_y * s->linesize + src_x;
01776 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
01777 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
01778
01779
01780 if(s->flags & CODEC_FLAG_GRAY) {
01781 srcU = s->edge_emu_buffer + 18 * s->linesize;
01782 srcV = s->edge_emu_buffer + 18 * s->linesize;
01783 }
01784
01785 if(v->rangeredfrm
01786 || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
01787 || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
01788 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
01789
01790 srcY -= s->mspel * (1 + s->linesize);
01791 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
01792 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
01793 srcY = s->edge_emu_buffer;
01794 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
01795 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
01796 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
01797 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
01798 srcU = uvbuf;
01799 srcV = uvbuf + 16;
01800
01801 if(v->rangeredfrm) {
01802 int i, j;
01803 uint8_t *src, *src2;
01804
01805 src = srcY;
01806 for(j = 0; j < 17 + s->mspel*2; j++) {
01807 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
01808 src += s->linesize;
01809 }
01810 src = srcU; src2 = srcV;
01811 for(j = 0; j < 9; j++) {
01812 for(i = 0; i < 9; i++) {
01813 src[i] = ((src[i] - 128) >> 1) + 128;
01814 src2[i] = ((src2[i] - 128) >> 1) + 128;
01815 }
01816 src += s->uvlinesize;
01817 src2 += s->uvlinesize;
01818 }
01819 }
01820 srcY += s->mspel * (1 + s->linesize);
01821 }
01822
01823 mx >>= 1;
01824 my >>= 1;
01825 dxy = ((my & 1) << 1) | (mx & 1);
01826
01827 dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
01828
01829 if(s->flags & CODEC_FLAG_GRAY) return;
01830
01831 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
01832 uvmx = (uvmx&3)<<1;
01833 uvmy = (uvmy&3)<<1;
01834 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
01835 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
01836 }
01837
01838 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
01839 {
01840 int n = bfrac;
01841
01842 #if B_FRACTION_DEN==256
01843 if(inv)
01844 n -= 256;
01845 if(!qs)
01846 return 2 * ((value * n + 255) >> 9);
01847 return (value * n + 128) >> 8;
01848 #else
01849 if(inv)
01850 n -= B_FRACTION_DEN;
01851 if(!qs)
01852 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
01853 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
01854 #endif
01855 }
01856
01859 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
01860 {
01861 if(v->use_ic) {
01862 v->mv_mode2 = v->mv_mode;
01863 v->mv_mode = MV_PMODE_INTENSITY_COMP;
01864 }
01865 if(direct) {
01866 vc1_mc_1mv(v, 0);
01867 vc1_interp_mc(v);
01868 if(v->use_ic) v->mv_mode = v->mv_mode2;
01869 return;
01870 }
01871 if(mode == BMV_TYPE_INTERPOLATED) {
01872 vc1_mc_1mv(v, 0);
01873 vc1_interp_mc(v);
01874 if(v->use_ic) v->mv_mode = v->mv_mode2;
01875 return;
01876 }
01877
01878 if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
01879 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
01880 if(v->use_ic) v->mv_mode = v->mv_mode2;
01881 }
01882
01883 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
01884 {
01885 MpegEncContext *s = &v->s;
01886 int xy, wrap, off = 0;
01887 int16_t *A, *B, *C;
01888 int px, py;
01889 int sum;
01890 int r_x, r_y;
01891 const uint8_t *is_intra = v->mb_type[0];
01892
01893 r_x = v->range_x;
01894 r_y = v->range_y;
01895
01896 dmv_x[0] <<= 1 - s->quarter_sample;
01897 dmv_y[0] <<= 1 - s->quarter_sample;
01898 dmv_x[1] <<= 1 - s->quarter_sample;
01899 dmv_y[1] <<= 1 - s->quarter_sample;
01900
01901 wrap = s->b8_stride;
01902 xy = s->block_index[0];
01903
01904 if(s->mb_intra) {
01905 s->current_picture.motion_val[0][xy][0] =
01906 s->current_picture.motion_val[0][xy][1] =
01907 s->current_picture.motion_val[1][xy][0] =
01908 s->current_picture.motion_val[1][xy][1] = 0;
01909 return;
01910 }
01911 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
01912 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
01913 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
01914 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
01915
01916
01917 s->mv[0][0][0] = av_clip(s->mv[0][0][0], -60 - (s->mb_x << 6), (s->mb_width << 6) - 4 - (s->mb_x << 6));
01918 s->mv[0][0][1] = av_clip(s->mv[0][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
01919 s->mv[1][0][0] = av_clip(s->mv[1][0][0], -60 - (s->mb_x << 6), (s->mb_width << 6) - 4 - (s->mb_x << 6));
01920 s->mv[1][0][1] = av_clip(s->mv[1][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
01921 if(direct) {
01922 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
01923 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
01924 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
01925 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
01926 return;
01927 }
01928
01929 if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
01930 C = s->current_picture.motion_val[0][xy - 2];
01931 A = s->current_picture.motion_val[0][xy - wrap*2];
01932 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
01933 B = s->current_picture.motion_val[0][xy - wrap*2 + off];
01934
01935 if(!s->mb_x) C[0] = C[1] = 0;
01936 if(!s->first_slice_line) {
01937 if(s->mb_width == 1) {
01938 px = A[0];
01939 py = A[1];
01940 } else {
01941 px = mid_pred(A[0], B[0], C[0]);
01942 py = mid_pred(A[1], B[1], C[1]);
01943 }
01944 } else if(s->mb_x) {
01945 px = C[0];
01946 py = C[1];
01947 } else {
01948 px = py = 0;
01949 }
01950
01951 {
01952 int qx, qy, X, Y;
01953 if(v->profile < PROFILE_ADVANCED) {
01954 qx = (s->mb_x << 5);
01955 qy = (s->mb_y << 5);
01956 X = (s->mb_width << 5) - 4;
01957 Y = (s->mb_height << 5) - 4;
01958 if(qx + px < -28) px = -28 - qx;
01959 if(qy + py < -28) py = -28 - qy;
01960 if(qx + px > X) px = X - qx;
01961 if(qy + py > Y) py = Y - qy;
01962 } else {
01963 qx = (s->mb_x << 6);
01964 qy = (s->mb_y << 6);
01965 X = (s->mb_width << 6) - 4;
01966 Y = (s->mb_height << 6) - 4;
01967 if(qx + px < -60) px = -60 - qx;
01968 if(qy + py < -60) py = -60 - qy;
01969 if(qx + px > X) px = X - qx;
01970 if(qy + py > Y) py = Y - qy;
01971 }
01972 }
01973
01974 if(0 && !s->first_slice_line && s->mb_x) {
01975 if(is_intra[xy - wrap])
01976 sum = FFABS(px) + FFABS(py);
01977 else
01978 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
01979 if(sum > 32) {
01980 if(get_bits1(&s->gb)) {
01981 px = A[0];
01982 py = A[1];
01983 } else {
01984 px = C[0];
01985 py = C[1];
01986 }
01987 } else {
01988 if(is_intra[xy - 2])
01989 sum = FFABS(px) + FFABS(py);
01990 else
01991 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
01992 if(sum > 32) {
01993 if(get_bits1(&s->gb)) {
01994 px = A[0];
01995 py = A[1];
01996 } else {
01997 px = C[0];
01998 py = C[1];
01999 }
02000 }
02001 }
02002 }
02003
02004 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
02005 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
02006 }
02007 if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
02008 C = s->current_picture.motion_val[1][xy - 2];
02009 A = s->current_picture.motion_val[1][xy - wrap*2];
02010 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
02011 B = s->current_picture.motion_val[1][xy - wrap*2 + off];
02012
02013 if(!s->mb_x) C[0] = C[1] = 0;
02014 if(!s->first_slice_line) {
02015 if(s->mb_width == 1) {
02016 px = A[0];
02017 py = A[1];
02018 } else {
02019 px = mid_pred(A[0], B[0], C[0]);
02020 py = mid_pred(A[1], B[1], C[1]);
02021 }
02022 } else if(s->mb_x) {
02023 px = C[0];
02024 py = C[1];
02025 } else {
02026 px = py = 0;
02027 }
02028
02029 {
02030 int qx, qy, X, Y;
02031 if(v->profile < PROFILE_ADVANCED) {
02032 qx = (s->mb_x << 5);
02033 qy = (s->mb_y << 5);
02034 X = (s->mb_width << 5) - 4;
02035 Y = (s->mb_height << 5) - 4;
02036 if(qx + px < -28) px = -28 - qx;
02037 if(qy + py < -28) py = -28 - qy;
02038 if(qx + px > X) px = X - qx;
02039 if(qy + py > Y) py = Y - qy;
02040 } else {
02041 qx = (s->mb_x << 6);
02042 qy = (s->mb_y << 6);
02043 X = (s->mb_width << 6) - 4;
02044 Y = (s->mb_height << 6) - 4;
02045 if(qx + px < -60) px = -60 - qx;
02046 if(qy + py < -60) py = -60 - qy;
02047 if(qx + px > X) px = X - qx;
02048 if(qy + py > Y) py = Y - qy;
02049 }
02050 }
02051
02052 if(0 && !s->first_slice_line && s->mb_x) {
02053 if(is_intra[xy - wrap])
02054 sum = FFABS(px) + FFABS(py);
02055 else
02056 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
02057 if(sum > 32) {
02058 if(get_bits1(&s->gb)) {
02059 px = A[0];
02060 py = A[1];
02061 } else {
02062 px = C[0];
02063 py = C[1];
02064 }
02065 } else {
02066 if(is_intra[xy - 2])
02067 sum = FFABS(px) + FFABS(py);
02068 else
02069 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
02070 if(sum > 32) {
02071 if(get_bits1(&s->gb)) {
02072 px = A[0];
02073 py = A[1];
02074 } else {
02075 px = C[0];
02076 py = C[1];
02077 }
02078 }
02079 }
02080 }
02081
02082
02083 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
02084 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
02085 }
02086 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
02087 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
02088 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
02089 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
02090 }
02091
02099 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
02100 int16_t **dc_val_ptr, int *dir_ptr)
02101 {
02102 int a, b, c, wrap, pred, scale;
02103 int16_t *dc_val;
02104 static const uint16_t dcpred[32] = {
02105 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
02106 114, 102, 93, 85, 79, 73, 68, 64,
02107 60, 57, 54, 51, 49, 47, 45, 43,
02108 41, 39, 38, 37, 35, 34, 33
02109 };
02110
02111
02112 if (n < 4) scale = s->y_dc_scale;
02113 else scale = s->c_dc_scale;
02114
02115 wrap = s->block_wrap[n];
02116 dc_val= s->dc_val[0] + s->block_index[n];
02117
02118
02119
02120
02121 c = dc_val[ - 1];
02122 b = dc_val[ - 1 - wrap];
02123 a = dc_val[ - wrap];
02124
02125 if (pq < 9 || !overlap)
02126 {
02127
02128 if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
02129 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
02130 }
02131 else
02132 {
02133
02134 if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
02135 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
02136 }
02137
02138 if (abs(a - b) <= abs(b - c)) {
02139 pred = c;
02140 *dir_ptr = 1;
02141 } else {
02142 pred = a;
02143 *dir_ptr = 0;
02144 }
02145
02146
02147 *dc_val_ptr = &dc_val[0];
02148 return pred;
02149 }
02150
02151
02159 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
02160 int a_avail, int c_avail,
02161 int16_t **dc_val_ptr, int *dir_ptr)
02162 {
02163 int a, b, c, wrap, pred, scale;
02164 int16_t *dc_val;
02165 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02166 int q1, q2 = 0;
02167
02168
02169 if (n < 4) scale = s->y_dc_scale;
02170 else scale = s->c_dc_scale;
02171
02172 wrap = s->block_wrap[n];
02173 dc_val= s->dc_val[0] + s->block_index[n];
02174
02175
02176
02177
02178 c = dc_val[ - 1];
02179 b = dc_val[ - 1 - wrap];
02180 a = dc_val[ - wrap];
02181
02182 q1 = s->current_picture.qscale_table[mb_pos];
02183 if(c_avail && (n!= 1 && n!=3)) {
02184 q2 = s->current_picture.qscale_table[mb_pos - 1];
02185 if(q2 && q2 != q1)
02186 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
02187 }
02188 if(a_avail && (n!= 2 && n!=3)) {
02189 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
02190 if(q2 && q2 != q1)
02191 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
02192 }
02193 if(a_avail && c_avail && (n!=3)) {
02194 int off = mb_pos;
02195 if(n != 1) off--;
02196 if(n != 2) off -= s->mb_stride;
02197 q2 = s->current_picture.qscale_table[off];
02198 if(q2 && q2 != q1)
02199 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
02200 }
02201
02202 if(a_avail && c_avail) {
02203 if(abs(a - b) <= abs(b - c)) {
02204 pred = c;
02205 *dir_ptr = 1;
02206 } else {
02207 pred = a;
02208 *dir_ptr = 0;
02209 }
02210 } else if(a_avail) {
02211 pred = a;
02212 *dir_ptr = 0;
02213 } else if(c_avail) {
02214 pred = c;
02215 *dir_ptr = 1;
02216 } else {
02217 pred = 0;
02218 *dir_ptr = 1;
02219 }
02220
02221
02222 *dc_val_ptr = &dc_val[0];
02223 return pred;
02224 }
02225
02226
02233 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
02234 {
02235 int xy, wrap, pred, a, b, c;
02236
02237 xy = s->block_index[n];
02238 wrap = s->b8_stride;
02239
02240
02241
02242
02243 a = s->coded_block[xy - 1 ];
02244 b = s->coded_block[xy - 1 - wrap];
02245 c = s->coded_block[xy - wrap];
02246
02247 if (b == c) {
02248 pred = a;
02249 } else {
02250 pred = c;
02251 }
02252
02253
02254 *coded_block_ptr = &s->coded_block[xy];
02255
02256 return pred;
02257 }
02258
02267 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
02268 {
02269 GetBitContext *gb = &v->s.gb;
02270 int index, escape, run = 0, level = 0, lst = 0;
02271
02272 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
02273 if (index != vc1_ac_sizes[codingset] - 1) {
02274 run = vc1_index_decode_table[codingset][index][0];
02275 level = vc1_index_decode_table[codingset][index][1];
02276 lst = index >= vc1_last_decode_table[codingset];
02277 if(get_bits1(gb))
02278 level = -level;
02279 } else {
02280 escape = decode210(gb);
02281 if (escape != 2) {
02282 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
02283 run = vc1_index_decode_table[codingset][index][0];
02284 level = vc1_index_decode_table[codingset][index][1];
02285 lst = index >= vc1_last_decode_table[codingset];
02286 if(escape == 0) {
02287 if(lst)
02288 level += vc1_last_delta_level_table[codingset][run];
02289 else
02290 level += vc1_delta_level_table[codingset][run];
02291 } else {
02292 if(lst)
02293 run += vc1_last_delta_run_table[codingset][level] + 1;
02294 else
02295 run += vc1_delta_run_table[codingset][level] + 1;
02296 }
02297 if(get_bits1(gb))
02298 level = -level;
02299 } else {
02300 int sign;
02301 lst = get_bits1(gb);
02302 if(v->s.esc3_level_length == 0) {
02303 if(v->pq < 8 || v->dquantfrm) {
02304 v->s.esc3_level_length = get_bits(gb, 3);
02305 if(!v->s.esc3_level_length)
02306 v->s.esc3_level_length = get_bits(gb, 2) + 8;
02307 } else {
02308 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
02309 }
02310 v->s.esc3_run_length = 3 + get_bits(gb, 2);
02311 }
02312 run = get_bits(gb, v->s.esc3_run_length);
02313 sign = get_bits1(gb);
02314 level = get_bits(gb, v->s.esc3_level_length);
02315 if(sign)
02316 level = -level;
02317 }
02318 }
02319
02320 *last = lst;
02321 *skip = run;
02322 *value = level;
02323 }
02324
02331 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
02332 {
02333 GetBitContext *gb = &v->s.gb;
02334 MpegEncContext *s = &v->s;
02335 int dc_pred_dir = 0;
02336 int run_diff, i;
02337 int16_t *dc_val;
02338 int16_t *ac_val, *ac_val2;
02339 int dcdiff;
02340
02341
02342 if (n < 4) {
02343 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02344 } else {
02345 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02346 }
02347 if (dcdiff < 0){
02348 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
02349 return -1;
02350 }
02351 if (dcdiff)
02352 {
02353 if (dcdiff == 119 )
02354 {
02355
02356 if (v->pq == 1) dcdiff = get_bits(gb, 10);
02357 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
02358 else dcdiff = get_bits(gb, 8);
02359 }
02360 else
02361 {
02362 if (v->pq == 1)
02363 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
02364 else if (v->pq == 2)
02365 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
02366 }
02367 if (get_bits1(gb))
02368 dcdiff = -dcdiff;
02369 }
02370
02371
02372 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
02373 *dc_val = dcdiff;
02374
02375
02376 if (n < 4) {
02377 block[0] = dcdiff * s->y_dc_scale;
02378 } else {
02379 block[0] = dcdiff * s->c_dc_scale;
02380 }
02381
02382 run_diff = 0;
02383 i = 0;
02384 if (!coded) {
02385 goto not_coded;
02386 }
02387
02388
02389 i = 1;
02390
02391 {
02392 int last = 0, skip, value;
02393 const int8_t *zz_table;
02394 int scale;
02395 int k;
02396
02397 scale = v->pq * 2 + v->halfpq;
02398
02399 if(v->s.ac_pred) {
02400 if(!dc_pred_dir)
02401 zz_table = ff_vc1_horizontal_zz;
02402 else
02403 zz_table = ff_vc1_vertical_zz;
02404 } else
02405 zz_table = ff_vc1_normal_zz;
02406
02407 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02408 ac_val2 = ac_val;
02409 if(dc_pred_dir)
02410 ac_val -= 16;
02411 else
02412 ac_val -= 16 * s->block_wrap[n];
02413
02414 while (!last) {
02415 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
02416 i += skip;
02417 if(i > 63)
02418 break;
02419 block[zz_table[i++]] = value;
02420 }
02421
02422
02423 if(s->ac_pred) {
02424 if(dc_pred_dir) {
02425 for(k = 1; k < 8; k++)
02426 block[k << 3] += ac_val[k];
02427 } else {
02428 for(k = 1; k < 8; k++)
02429 block[k] += ac_val[k + 8];
02430 }
02431 }
02432
02433 for(k = 1; k < 8; k++) {
02434 ac_val2[k] = block[k << 3];
02435 ac_val2[k + 8] = block[k];
02436 }
02437
02438
02439 for(k = 1; k < 64; k++)
02440 if(block[k]) {
02441 block[k] *= scale;
02442 if(!v->pquantizer)
02443 block[k] += (block[k] < 0) ? -v->pq : v->pq;
02444 }
02445
02446 if(s->ac_pred) i = 63;
02447 }
02448
02449 not_coded:
02450 if(!coded) {
02451 int k, scale;
02452 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02453 ac_val2 = ac_val;
02454
02455 scale = v->pq * 2 + v->halfpq;
02456 memset(ac_val2, 0, 16 * 2);
02457 if(dc_pred_dir) {
02458 ac_val -= 16;
02459 if(s->ac_pred)
02460 memcpy(ac_val2, ac_val, 8 * 2);
02461 } else {
02462 ac_val -= 16 * s->block_wrap[n];
02463 if(s->ac_pred)
02464 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
02465 }
02466
02467
02468 if(s->ac_pred) {
02469 if(dc_pred_dir) {
02470 for(k = 1; k < 8; k++) {
02471 block[k << 3] = ac_val[k] * scale;
02472 if(!v->pquantizer && block[k << 3])
02473 block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
02474 }
02475 } else {
02476 for(k = 1; k < 8; k++) {
02477 block[k] = ac_val[k + 8] * scale;
02478 if(!v->pquantizer && block[k])
02479 block[k] += (block[k] < 0) ? -v->pq : v->pq;
02480 }
02481 }
02482 i = 63;
02483 }
02484 }
02485 s->block_last_index[n] = i;
02486
02487 return 0;
02488 }
02489
02496 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
02497 {
02498 GetBitContext *gb = &v->s.gb;
02499 MpegEncContext *s = &v->s;
02500 int dc_pred_dir = 0;
02501 int run_diff, i;
02502 int16_t *dc_val;
02503 int16_t *ac_val, *ac_val2;
02504 int dcdiff;
02505 int a_avail = v->a_avail, c_avail = v->c_avail;
02506 int use_pred = s->ac_pred;
02507 int scale;
02508 int q1, q2 = 0;
02509 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02510
02511
02512 if (n < 4) {
02513 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02514 } else {
02515 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02516 }
02517 if (dcdiff < 0){
02518 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
02519 return -1;
02520 }
02521 if (dcdiff)
02522 {
02523 if (dcdiff == 119 )
02524 {
02525
02526 if (mquant == 1) dcdiff = get_bits(gb, 10);
02527 else if (mquant == 2) dcdiff = get_bits(gb, 9);
02528 else dcdiff = get_bits(gb, 8);
02529 }
02530 else
02531 {
02532 if (mquant == 1)
02533 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
02534 else if (mquant == 2)
02535 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
02536 }
02537 if (get_bits1(gb))
02538 dcdiff = -dcdiff;
02539 }
02540
02541
02542 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
02543 *dc_val = dcdiff;
02544
02545
02546 if (n < 4) {
02547 block[0] = dcdiff * s->y_dc_scale;
02548 } else {
02549 block[0] = dcdiff * s->c_dc_scale;
02550 }
02551
02552 run_diff = 0;
02553 i = 0;
02554
02555
02556 i = 1;
02557
02558
02559 if(!a_avail && !c_avail) use_pred = 0;
02560 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02561 ac_val2 = ac_val;
02562
02563 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
02564
02565 if(dc_pred_dir)
02566 ac_val -= 16;
02567 else
02568 ac_val -= 16 * s->block_wrap[n];
02569
02570 q1 = s->current_picture.qscale_table[mb_pos];
02571 if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
02572 if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
02573 if(dc_pred_dir && n==1) q2 = q1;
02574 if(!dc_pred_dir && n==2) q2 = q1;
02575 if(n==3) q2 = q1;
02576
02577 if(coded) {
02578 int last = 0, skip, value;
02579 const int8_t *zz_table;
02580 int k;
02581
02582 if(v->s.ac_pred) {
02583 if(!dc_pred_dir)
02584 zz_table = ff_vc1_horizontal_zz;
02585 else
02586 zz_table = ff_vc1_vertical_zz;
02587 } else
02588 zz_table = ff_vc1_normal_zz;
02589
02590 while (!last) {
02591 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
02592 i += skip;
02593 if(i > 63)
02594 break;
02595 block[zz_table[i++]] = value;
02596 }
02597
02598
02599 if(use_pred) {
02600
02601 if(q2 && q1!=q2) {
02602 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02603 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02604
02605 if(dc_pred_dir) {
02606 for(k = 1; k < 8; k++)
02607 block[k << 3] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02608 } else {
02609 for(k = 1; k < 8; k++)
02610 block[k] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02611 }
02612 } else {
02613 if(dc_pred_dir) {
02614 for(k = 1; k < 8; k++)
02615 block[k << 3] += ac_val[k];
02616 } else {
02617 for(k = 1; k < 8; k++)
02618 block[k] += ac_val[k + 8];
02619 }
02620 }
02621 }
02622
02623 for(k = 1; k < 8; k++) {
02624 ac_val2[k] = block[k << 3];
02625 ac_val2[k + 8] = block[k];
02626 }
02627
02628
02629 for(k = 1; k < 64; k++)
02630 if(block[k]) {
02631 block[k] *= scale;
02632 if(!v->pquantizer)
02633 block[k] += (block[k] < 0) ? -mquant : mquant;
02634 }
02635
02636 if(use_pred) i = 63;
02637 } else {
02638 int k;
02639
02640 memset(ac_val2, 0, 16 * 2);
02641 if(dc_pred_dir) {
02642 if(use_pred) {
02643 memcpy(ac_val2, ac_val, 8 * 2);
02644 if(q2 && q1!=q2) {
02645 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02646 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02647 for(k = 1; k < 8; k++)
02648 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02649 }
02650 }
02651 } else {
02652 if(use_pred) {
02653 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
02654 if(q2 && q1!=q2) {
02655 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02656 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02657 for(k = 1; k < 8; k++)
02658 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02659 }
02660 }
02661 }
02662
02663
02664 if(use_pred) {
02665 if(dc_pred_dir) {
02666 for(k = 1; k < 8; k++) {
02667 block[k << 3] = ac_val2[k] * scale;
02668 if(!v->pquantizer && block[k << 3])
02669 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
02670 }
02671 } else {
02672 for(k = 1; k < 8; k++) {
02673 block[k] = ac_val2[k + 8] * scale;
02674 if(!v->pquantizer && block[k])
02675 block[k] += (block[k] < 0) ? -mquant : mquant;
02676 }
02677 }
02678 i = 63;
02679 }
02680 }
02681 s->block_last_index[n] = i;
02682
02683 return 0;
02684 }
02685
02693 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
02694 {
02695 GetBitContext *gb = &v->s.gb;
02696 MpegEncContext *s = &v->s;
02697 int dc_pred_dir = 0;
02698 int run_diff, i;
02699 int16_t *dc_val;
02700 int16_t *ac_val, *ac_val2;
02701 int dcdiff;
02702 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02703 int a_avail = v->a_avail, c_avail = v->c_avail;
02704 int use_pred = s->ac_pred;
02705 int scale;
02706 int q1, q2 = 0;
02707
02708
02709 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
02710
02711
02712 s->y_dc_scale = s->y_dc_scale_table[mquant];
02713 s->c_dc_scale = s->c_dc_scale_table[mquant];
02714
02715
02716 if (n < 4) {
02717 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02718 } else {
02719 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02720 }
02721 if (dcdiff < 0){
02722 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
02723 return -1;
02724 }
02725 if (dcdiff)
02726 {
02727 if (dcdiff == 119 )
02728 {
02729
02730 if (mquant == 1) dcdiff = get_bits(gb, 10);
02731 else if (mquant == 2) dcdiff = get_bits(gb, 9);
02732 else dcdiff = get_bits(gb, 8);
02733 }
02734 else
02735 {
02736 if (mquant == 1)
02737 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
02738 else if (mquant == 2)
02739 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
02740 }
02741 if (get_bits1(gb))
02742 dcdiff = -dcdiff;
02743 }
02744
02745
02746 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
02747 *dc_val = dcdiff;
02748
02749
02750
02751 if (n < 4) {
02752 block[0] = dcdiff * s->y_dc_scale;
02753 } else {
02754 block[0] = dcdiff * s->c_dc_scale;
02755 }
02756
02757 run_diff = 0;
02758 i = 0;
02759
02760
02761 i = 1;
02762
02763
02764 if(!a_avail) dc_pred_dir = 1;
02765 if(!c_avail) dc_pred_dir = 0;
02766 if(!a_avail && !c_avail) use_pred = 0;
02767 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02768 ac_val2 = ac_val;
02769
02770 scale = mquant * 2 + v->halfpq;
02771
02772 if(dc_pred_dir)
02773 ac_val -= 16;
02774 else
02775 ac_val -= 16 * s->block_wrap[n];
02776
02777 q1 = s->current_picture.qscale_table[mb_pos];
02778 if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
02779 if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
02780 if(dc_pred_dir && n==1) q2 = q1;
02781 if(!dc_pred_dir && n==2) q2 = q1;
02782 if(n==3) q2 = q1;
02783
02784 if(coded) {
02785 int last = 0, skip, value;
02786 const int8_t *zz_table;
02787 int k;
02788
02789 zz_table = ff_vc1_simple_progressive_8x8_zz;
02790
02791 while (!last) {
02792 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
02793 i += skip;
02794 if(i > 63)
02795 break;
02796 block[zz_table[i++]] = value;
02797 }
02798
02799
02800 if(use_pred) {
02801
02802 if(q2 && q1!=q2) {
02803 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02804 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02805
02806 if(dc_pred_dir) {
02807 for(k = 1; k < 8; k++)
02808 block[k << 3] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02809 } else {
02810 for(k = 1; k < 8; k++)
02811 block[k] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02812 }
02813 } else {
02814 if(dc_pred_dir) {
02815 for(k = 1; k < 8; k++)
02816 block[k << 3] += ac_val[k];
02817 } else {
02818 for(k = 1; k < 8; k++)
02819 block[k] += ac_val[k + 8];
02820 }
02821 }
02822 }
02823
02824 for(k = 1; k < 8; k++) {
02825 ac_val2[k] = block[k << 3];
02826 ac_val2[k + 8] = block[k];
02827 }
02828
02829
02830 for(k = 1; k < 64; k++)
02831 if(block[k]) {
02832 block[k] *= scale;
02833 if(!v->pquantizer)
02834 block[k] += (block[k] < 0) ? -mquant : mquant;
02835 }
02836
02837 if(use_pred) i = 63;
02838 } else {
02839 int k;
02840
02841 memset(ac_val2, 0, 16 * 2);
02842 if(dc_pred_dir) {
02843 if(use_pred) {
02844 memcpy(ac_val2, ac_val, 8 * 2);
02845 if(q2 && q1!=q2) {
02846 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02847 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02848 for(k = 1; k < 8; k++)
02849 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02850 }
02851 }
02852 } else {
02853 if(use_pred) {
02854 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
02855 if(q2 && q1!=q2) {
02856 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02857 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02858 for(k = 1; k < 8; k++)
02859 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02860 }
02861 }
02862 }
02863
02864
02865 if(use_pred) {
02866 if(dc_pred_dir) {
02867 for(k = 1; k < 8; k++) {
02868 block[k << 3] = ac_val2[k] * scale;
02869 if(!v->pquantizer && block[k << 3])
02870 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
02871 }
02872 } else {
02873 for(k = 1; k < 8; k++) {
02874 block[k] = ac_val2[k + 8] * scale;
02875 if(!v->pquantizer && block[k])
02876 block[k] += (block[k] < 0) ? -mquant : mquant;
02877 }
02878 }
02879 i = 63;
02880 }
02881 }
02882 s->block_last_index[n] = i;
02883
02884 return 0;
02885 }
02886
02889 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block,
02890 uint8_t *dst, int linesize, int skip_block)
02891 {
02892 MpegEncContext *s = &v->s;
02893 GetBitContext *gb = &s->gb;
02894 int i, j;
02895 int subblkpat = 0;
02896 int scale, off, idx, last, skip, value;
02897 int ttblk = ttmb & 7;
02898
02899 if(ttmb == -1) {
02900 ttblk = ff_vc1_ttblk_to_tt[v->tt_index][get_vlc2(gb, ff_vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
02901 }
02902 if(ttblk == TT_4X4) {
02903 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
02904 }
02905 if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
02906 subblkpat = decode012(gb);
02907 if(subblkpat) subblkpat ^= 3;
02908 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
02909 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
02910 }
02911 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
02912
02913
02914 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
02915 subblkpat = 2 - (ttblk == TT_8X4_TOP);
02916 ttblk = TT_8X4;
02917 }
02918 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
02919 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
02920 ttblk = TT_4X8;
02921 }
02922 switch(ttblk) {
02923 case TT_8X8:
02924 i = 0;
02925 last = 0;
02926 while (!last) {
02927 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02928 i += skip;
02929 if(i > 63)
02930 break;
02931 idx = ff_vc1_simple_progressive_8x8_zz[i++];
02932 block[idx] = value * scale;
02933 if(!v->pquantizer)
02934 block[idx] += (block[idx] < 0) ? -mquant : mquant;
02935 }
02936 if(!skip_block){
02937 s->dsp.vc1_inv_trans_8x8(block);
02938 s->dsp.add_pixels_clamped(block, dst, linesize);
02939 }
02940 break;
02941 case TT_4X4:
02942 for(j = 0; j < 4; j++) {
02943 last = subblkpat & (1 << (3 - j));
02944 i = 0;
02945 off = (j & 1) * 4 + (j & 2) * 16;
02946 while (!last) {
02947 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02948 i += skip;
02949 if(i > 15)
02950 break;
02951 idx = ff_vc1_simple_progressive_4x4_zz[i++];
02952 block[idx + off] = value * scale;
02953 if(!v->pquantizer)
02954 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
02955 }
02956 if(!(subblkpat & (1 << (3 - j))) && !skip_block)
02957 s->dsp.vc1_inv_trans_4x4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off);
02958 }
02959 break;
02960 case TT_8X4:
02961 for(j = 0; j < 2; j++) {
02962 last = subblkpat & (1 << (1 - j));
02963 i = 0;
02964 off = j * 32;
02965 while (!last) {
02966 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02967 i += skip;
02968 if(i > 31)
02969 break;
02970 idx = v->zz_8x4[i++]+off;
02971 block[idx] = value * scale;
02972 if(!v->pquantizer)
02973 block[idx] += (block[idx] < 0) ? -mquant : mquant;
02974 }
02975 if(!(subblkpat & (1 << (1 - j))) && !skip_block)
02976 s->dsp.vc1_inv_trans_8x4(dst + j*4*linesize, linesize, block + off);
02977 }
02978 break;
02979 case TT_4X8:
02980 for(j = 0; j < 2; j++) {
02981 last = subblkpat & (1 << (1 - j));
02982 i = 0;
02983 off = j * 4;
02984 while (!last) {
02985 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02986 i += skip;
02987 if(i > 31)
02988 break;
02989 idx = v->zz_4x8[i++]+off;
02990 block[idx] = value * scale;
02991 if(!v->pquantizer)
02992 block[idx] += (block[idx] < 0) ? -mquant : mquant;
02993 }
02994 if(!(subblkpat & (1 << (1 - j))) && !skip_block)
02995 s->dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
02996 }
02997 break;
02998 }
02999 return 0;
03000 }
03001
03002
03005 static int vc1_decode_p_mb(VC1Context *v)
03006 {
03007 MpegEncContext *s = &v->s;
03008 GetBitContext *gb = &s->gb;
03009 int i, j;
03010 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
03011 int cbp;
03012 int mqdiff, mquant;
03013 int ttmb = v->ttfrm;
03014 int status;
03015
03016 static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
03017 offset_table[6] = { 0, 1, 3, 7, 15, 31 };
03018 int mb_has_coeffs = 1;
03019 int dmv_x, dmv_y;
03020 int index, index1;
03021 int val, sign;
03022 int first_block = 1;
03023 int dst_idx, off;
03024 int skipped, fourmv;
03025
03026 mquant = v->pq;
03027
03028 if (v->mv_type_is_raw)
03029 fourmv = get_bits1(gb);
03030 else
03031 fourmv = v->mv_type_mb_plane[mb_pos];
03032 if (v->skip_is_raw)
03033 skipped = get_bits1(gb);
03034 else
03035 skipped = v->s.mbskip_table[mb_pos];
03036
03037 s->dsp.clear_blocks(s->block[0]);
03038
03039 if (!fourmv)
03040 {
03041 if (!skipped)
03042 {
03043 GET_MVDATA(dmv_x, dmv_y);
03044
03045 if (s->mb_intra) {
03046 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
03047 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
03048 }
03049 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
03050 vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
03051
03052
03053 if (s->mb_intra && !mb_has_coeffs)
03054 {
03055 GET_MQUANT();
03056 s->ac_pred = get_bits1(gb);
03057 cbp = 0;
03058 }
03059 else if (mb_has_coeffs)
03060 {
03061 if (s->mb_intra) s->ac_pred = get_bits1(gb);
03062 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03063 GET_MQUANT();
03064 }
03065 else
03066 {
03067 mquant = v->pq;
03068 cbp = 0;
03069 }
03070 s->current_picture.qscale_table[mb_pos] = mquant;
03071
03072 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
03073 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
03074 VC1_TTMB_VLC_BITS, 2);
03075 if(!s->mb_intra) vc1_mc_1mv(v, 0);
03076 dst_idx = 0;
03077 for (i=0; i<6; i++)
03078 {
03079 s->dc_val[0][s->block_index[i]] = 0;
03080 dst_idx += i >> 2;
03081 val = ((cbp >> (5 - i)) & 1);
03082 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
03083 v->mb_type[0][s->block_index[i]] = s->mb_intra;
03084 if(s->mb_intra) {
03085
03086 v->a_avail = v->c_avail = 0;
03087 if(i == 2 || i == 3 || !s->first_slice_line)
03088 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
03089 if(i == 1 || i == 3 || s->mb_x)
03090 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
03091
03092 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
03093 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
03094 s->dsp.vc1_inv_trans_8x8(s->block[i]);
03095 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
03096 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
03097 if(v->pq >= 9 && v->overlap) {
03098 if(v->c_avail)
03099 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
03100 if(v->a_avail)
03101 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
03102 }
03103 } else if(val) {
03104 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY));
03105 if(!v->ttmbf && ttmb < 8) ttmb = -1;
03106 first_block = 0;
03107 }
03108 }
03109 }
03110 else
03111 {
03112 s->mb_intra = 0;
03113 for(i = 0; i < 6; i++) {
03114 v->mb_type[0][s->block_index[i]] = 0;
03115 s->dc_val[0][s->block_index[i]] = 0;
03116 }
03117 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
03118 s->current_picture.qscale_table[mb_pos] = 0;
03119 vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
03120 vc1_mc_1mv(v, 0);
03121 return 0;
03122 }
03123 }
03124 else
03125 {
03126 if (!skipped )
03127 {
03128 int intra_count = 0, coded_inter = 0;
03129 int is_intra[6], is_coded[6];
03130
03131 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03132 for (i=0; i<6; i++)
03133 {
03134 val = ((cbp >> (5 - i)) & 1);
03135 s->dc_val[0][s->block_index[i]] = 0;
03136 s->mb_intra = 0;
03137 if(i < 4) {
03138 dmv_x = dmv_y = 0;
03139 s->mb_intra = 0;
03140 mb_has_coeffs = 0;
03141 if(val) {
03142 GET_MVDATA(dmv_x, dmv_y);
03143 }
03144 vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
03145 if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
03146 intra_count += s->mb_intra;
03147 is_intra[i] = s->mb_intra;
03148 is_coded[i] = mb_has_coeffs;
03149 }
03150 if(i&4){
03151 is_intra[i] = (intra_count >= 3);
03152 is_coded[i] = val;
03153 }
03154 if(i == 4) vc1_mc_4mv_chroma(v);
03155 v->mb_type[0][s->block_index[i]] = is_intra[i];
03156 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
03157 }
03158
03159 if(!intra_count && !coded_inter) return 0;
03160 dst_idx = 0;
03161 GET_MQUANT();
03162 s->current_picture.qscale_table[mb_pos] = mquant;
03163
03164 {
03165 int intrapred = 0;
03166 for(i=0; i<6; i++)
03167 if(is_intra[i]) {
03168 if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
03169 || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
03170 intrapred = 1;
03171 break;
03172 }
03173 }
03174 if(intrapred)s->ac_pred = get_bits1(gb);
03175 else s->ac_pred = 0;
03176 }
03177 if (!v->ttmbf && coded_inter)
03178 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
03179 for (i=0; i<6; i++)
03180 {
03181 dst_idx += i >> 2;
03182 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
03183 s->mb_intra = is_intra[i];
03184 if (is_intra[i]) {
03185
03186 v->a_avail = v->c_avail = 0;
03187 if(i == 2 || i == 3 || !s->first_slice_line)
03188 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
03189 if(i == 1 || i == 3 || s->mb_x)
03190 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
03191
03192 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
03193 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
03194 s->dsp.vc1_inv_trans_8x8(s->block[i]);
03195 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
03196 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
03197 if(v->pq >= 9 && v->overlap) {
03198 if(v->c_avail)
03199 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
03200 if(v->a_avail)
03201 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
03202 }
03203 } else if(is_coded[i]) {
03204 status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY));
03205 if(!v->ttmbf && ttmb < 8) ttmb = -1;
03206 first_block = 0;
03207 }
03208 }
03209 return status;
03210 }
03211 else
03212 {
03213 s->mb_intra = 0;
03214 s->current_picture.qscale_table[mb_pos] = 0;
03215 for (i=0; i<6; i++) {
03216 v->mb_type[0][s->block_index[i]] = 0;
03217 s->dc_val[0][s->block_index[i]] = 0;
03218 }
03219 for (i=0; i<4; i++)
03220 {
03221 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
03222 vc1_mc_4mv_luma(v, i);
03223 }
03224 vc1_mc_4mv_chroma(v);
03225 s->current_picture.qscale_table[mb_pos] = 0;
03226 return 0;
03227 }
03228 }
03229
03230
03231 return -1;
03232 }
03233
03236 static void vc1_decode_b_mb(VC1Context *v)
03237 {
03238 MpegEncContext *s = &v->s;
03239 GetBitContext *gb = &s->gb;
03240 int i, j;
03241 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
03242 int cbp = 0;
03243 int mqdiff, mquant;
03244 int ttmb = v->ttfrm;
03245
03246 static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
03247 offset_table[6] = { 0, 1, 3, 7, 15, 31 };
03248 int mb_has_coeffs = 0;
03249 int index, index1;
03250 int val, sign;
03251 int first_block = 1;
03252 int dst_idx, off;
03253 int skipped, direct;
03254 int dmv_x[2], dmv_y[2];
03255 int bmvtype = BMV_TYPE_BACKWARD;
03256
03257 mquant = v->pq;
03258 s->mb_intra = 0;
03259
03260 if (v->dmb_is_raw)
03261 direct = get_bits1(gb);
03262 else
03263 direct = v->direct_mb_plane[mb_pos];
03264 if (v->skip_is_raw)
03265 skipped = get_bits1(gb);
03266 else
03267 skipped = v->s.mbskip_table[mb_pos];
03268
03269 s->dsp.clear_blocks(s->block[0]);
03270 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
03271 for(i = 0; i < 6; i++) {
03272 v->mb_type[0][s->block_index[i]] = 0;
03273 s->dc_val[0][s->block_index[i]] = 0;
03274 }
03275 s->current_picture.qscale_table[mb_pos] = 0;
03276
03277 if (!direct) {
03278 if (!skipped) {
03279 GET_MVDATA(dmv_x[0], dmv_y[0]);
03280 dmv_x[1] = dmv_x[0];
03281 dmv_y[1] = dmv_y[0];
03282 }
03283 if(skipped || !s->mb_intra) {
03284 bmvtype = decode012(gb);
03285 switch(bmvtype) {
03286 case 0:
03287 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
03288 break;
03289 case 1:
03290 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
03291 break;
03292 case 2:
03293 bmvtype = BMV_TYPE_INTERPOLATED;
03294 dmv_x[0] = dmv_y[0] = 0;
03295 }
03296 }
03297 }
03298 for(i = 0; i < 6; i++)
03299 v->mb_type[0][s->block_index[i]] = s->mb_intra;
03300
03301 if (skipped) {
03302 if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
03303 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
03304 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
03305 return;
03306 }
03307 if (direct) {
03308 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03309 GET_MQUANT();
03310 s->mb_intra = 0;
03311 mb_has_coeffs = 0;
03312 s->current_picture.qscale_table[mb_pos] = mquant;
03313 if(!v->ttmbf)
03314 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
03315 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
03316 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
03317 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
03318 } else {
03319 if(!mb_has_coeffs && !s->mb_intra) {
03320
03321 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
03322 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
03323 return;
03324 }
03325 if(s->mb_intra && !mb_has_coeffs) {
03326 GET_MQUANT();
03327 s->current_picture.qscale_table[mb_pos] = mquant;
03328 s->ac_pred = get_bits1(gb);
03329 cbp = 0;
03330 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
03331 } else {
03332 if(bmvtype == BMV_TYPE_INTERPOLATED) {
03333 GET_MVDATA(dmv_x[0], dmv_y[0]);
03334 if(!mb_has_coeffs) {
03335
03336 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
03337 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
03338 return;
03339 }
03340 }
03341 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
03342 if(!s->mb_intra) {
03343 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
03344 }
03345 if(s->mb_intra)
03346 s->ac_pred = get_bits1(gb);
03347 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03348 GET_MQUANT();
03349 s->current_picture.qscale_table[mb_pos] = mquant;
03350 if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
03351 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
03352 }
03353 }
03354 dst_idx = 0;
03355 for (i=0; i<6; i++)
03356 {
03357 s->dc_val[0][s->block_index[i]] = 0;
03358 dst_idx += i >> 2;
03359 val = ((cbp >> (5 - i)) & 1);
03360 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
03361 v->mb_type[0][s->block_index[i]] = s->mb_intra;
03362 if(s->mb_intra) {
03363
03364 v->a_avail = v->c_avail = 0;
03365 if(i == 2 || i == 3 || !s->first_slice_line)
03366 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
03367 if(i == 1 || i == 3 || s->mb_x)
03368 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
03369
03370 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
03371 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
03372 s->dsp.vc1_inv_trans_8x8(s->block[i]);
03373 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
03374 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
03375 } else if(val) {
03376 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY));
03377 if(!v->ttmbf && ttmb < 8) ttmb = -1;
03378 first_block = 0;
03379 }
03380 }
03381 }
03382
03385 static void vc1_decode_i_blocks(VC1Context *v)
03386 {
03387 int k, j;
03388 MpegEncContext *s = &v->s;
03389 int cbp, val;
03390 uint8_t *coded_val;
03391 int mb_pos;
03392
03393
03394 switch(v->y_ac_table_index){
03395 case 0:
03396 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
03397 break;
03398 case 1:
03399 v->codingset = CS_HIGH_MOT_INTRA;
03400 break;
03401 case 2:
03402 v->codingset = CS_MID_RATE_INTRA;
03403 break;
03404 }
03405
03406 switch(v->c_ac_table_index){
03407 case 0:
03408 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
03409 break;
03410 case 1:
03411 v->codingset2 = CS_HIGH_MOT_INTER;
03412 break;
03413 case 2:
03414 v->codingset2 = CS_MID_RATE_INTER;
03415 break;
03416 }
03417
03418
03419 s->y_dc_scale = s->y_dc_scale_table[v->pq];
03420 s->c_dc_scale = s->c_dc_scale_table[v->pq];
03421
03422
03423 s->mb_x = s->mb_y = 0;
03424 s->mb_intra = 1;
03425 s->first_slice_line = 1;
03426 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
03427 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
03428 ff_init_block_index(s);
03429 ff_update_block_index(s);
03430 s->dsp.clear_blocks(s->block[0]);
03431 mb_pos = s->mb_x + s->mb_y * s->mb_width;
03432 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
03433 s->current_picture.qscale_table[mb_pos] = v->pq;
03434 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
03435 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
03436
03437
03438 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
03439 v->s.ac_pred = get_bits1(&v->s.gb);
03440
03441 for(k = 0; k < 6; k++) {
03442 val = ((cbp >> (5 - k)) & 1);
03443
03444 if (k < 4) {
03445 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
03446 val = val ^ pred;
03447 *coded_val = val;
03448 }
03449 cbp |= val << (5 - k);
03450
03451 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
03452
03453 s->dsp.vc1_inv_trans_8x8(s->block[k]);
03454 if(v->pq >= 9 && v->overlap) {
03455 for(j = 0; j < 64; j++) s->block[k][j] += 128;
03456 }
03457 }
03458
03459 vc1_put_block(v, s->block);
03460 if(v->pq >= 9 && v->overlap) {
03461 if(s->mb_x) {
03462 s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
03463 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
03464 if(!(s->flags & CODEC_FLAG_GRAY)) {
03465 s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
03466 s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
03467 }
03468 }
03469 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
03470 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
03471 if(!s->first_slice_line) {
03472 s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
03473 s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
03474 if(!(s->flags & CODEC_FLAG_GRAY)) {
03475 s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
03476 s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
03477 }
03478 }
03479 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
03480 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
03481 }
03482
03483 if(get_bits_count(&s->gb) > v->bits) {
03484 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
03485 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
03486 return;
03487 }
03488 }
03489 ff_draw_horiz_band(s, s->mb_y * 16, 16);
03490 s->first_slice_line = 0;
03491 }
03492 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
03493 }
03494
03497 static void vc1_decode_i_blocks_adv(VC1Context *v)
03498 {
03499 int k, j;
03500 MpegEncContext *s = &v->s;
03501 int cbp, val;
03502 uint8_t *coded_val;
03503 int mb_pos;
03504 int mquant = v->pq;
03505 int mqdiff;
03506 int overlap;
03507 GetBitContext *gb = &s->gb;
03508
03509
03510 switch(v->y_ac_table_index){
03511 case 0:
03512 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
03513 break;
03514 case 1:
03515 v->codingset = CS_HIGH_MOT_INTRA;
03516 break;
03517 case 2:
03518 v->codingset = CS_MID_RATE_INTRA;
03519 break;
03520 }
03521
03522 switch(v->c_ac_table_index){
03523 case 0:
03524 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
03525 break;
03526 case 1:
03527 v->codingset2 = CS_HIGH_MOT_INTER;
03528 break;
03529 case 2:
03530 v->codingset2 = CS_MID_RATE_INTER;
03531 break;
03532 }
03533
03534
03535 s->mb_x = s->mb_y = 0;
03536 s->mb_intra = 1;
03537 s->first_slice_line = 1;
03538 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
03539 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
03540 ff_init_block_index(s);
03541 ff_update_block_index(s);
03542 s->dsp.clear_blocks(s->block[0]);
03543 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
03544 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
03545 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
03546 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
03547
03548
03549 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
03550 if(v->acpred_is_raw)
03551 v->s.ac_pred = get_bits1(&v->s.gb);
03552 else
03553 v->s.ac_pred = v->acpred_plane[mb_pos];
03554
03555 if(v->condover == CONDOVER_SELECT) {
03556 if(v->overflg_is_raw)
03557 overlap = get_bits1(&v->s.gb);
03558 else
03559 overlap = v->over_flags_plane[mb_pos];
03560 } else
03561 overlap = (v->condover == CONDOVER_ALL);
03562
03563 GET_MQUANT();
03564
03565 s->current_picture.qscale_table[mb_pos] = mquant;
03566
03567 s->y_dc_scale = s->y_dc_scale_table[mquant];
03568 s->c_dc_scale = s->c_dc_scale_table[mquant];
03569
03570 for(k = 0; k < 6; k++) {
03571 val = ((cbp >> (5 - k)) & 1);
03572
03573 if (k < 4) {
03574 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
03575 val = val ^ pred;
03576 *coded_val = val;
03577 }
03578 cbp |= val << (5 - k);
03579
03580 v->a_avail = !s->first_slice_line || (k==2 || k==3);
03581 v->c_avail = !!s->mb_x || (k==1 || k==3);
03582
03583 vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
03584
03585 s->dsp.vc1_inv_trans_8x8(s->block[k]);
03586 for(j = 0; j < 64; j++) s->block[k][j] += 128;
03587 }
03588
03589 vc1_put_block(v, s->block);
03590 if(overlap) {
03591 if(s->mb_x) {
03592 s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
03593 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
03594 if(!(s->flags & CODEC_FLAG_GRAY)) {
03595 s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
03596 s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
03597 }
03598 }
03599 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
03600 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
03601 if(!s->first_slice_line) {
03602 s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
03603 s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
03604 if(!(s->flags & CODEC_FLAG_GRAY)) {
03605 s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
03606 s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
03607 }
03608 }
03609 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
03610 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
03611 }
03612
03613 if(get_bits_count(&s->gb) > v->bits) {
03614 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
03615 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
03616 return;
03617 }
03618 }
03619 ff_draw_horiz_band(s, s->mb_y * 16, 16);
03620 s->first_slice_line = 0;
03621 }
03622 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
03623 }
03624
03625 static void vc1_decode_p_blocks(VC1Context *v)
03626 {
03627 MpegEncContext *s = &v->s;
03628
03629
03630 switch(v->c_ac_table_index){
03631 case 0:
03632 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
03633 break;
03634 case 1:
03635 v->codingset = CS_HIGH_MOT_INTRA;
03636 break;
03637 case 2:
03638 v->codingset = CS_MID_RATE_INTRA;
03639 break;
03640 }
03641
03642 switch(v->c_ac_table_index){
03643 case 0:
03644 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
03645 break;
03646 case 1:
03647 v->codingset2 = CS_HIGH_MOT_INTER;
03648 break;
03649 case 2:
03650 v->codingset2 = CS_MID_RATE_INTER;
03651 break;
03652 }
03653
03654 s->first_slice_line = 1;
03655 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
03656 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
03657 ff_init_block_index(s);
03658 ff_update_block_index(s);
03659 s->dsp.clear_blocks(s->block[0]);
03660
03661 vc1_decode_p_mb(v);
03662 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
03663 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
03664 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
03665 return;
03666 }
03667 }
03668 ff_draw_horiz_band(s, s->mb_y * 16, 16);
03669 s->first_slice_line = 0;
03670 }
03671 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
03672 }
03673
03674 static void vc1_decode_b_blocks(VC1Context *v)
03675 {
03676 MpegEncContext *s = &v->s;
03677
03678
03679 switch(v->c_ac_table_index){
03680 case 0:
03681 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
03682 break;
03683 case 1:
03684 v->codingset = CS_HIGH_MOT_INTRA;
03685 break;
03686 case 2:
03687 v->codingset = CS_MID_RATE_INTRA;
03688 break;
03689 }
03690
03691 switch(v->c_ac_table_index){
03692 case 0:
03693 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
03694 break;
03695 case 1:
03696 v->codingset2 = CS_HIGH_MOT_INTER;
03697 break;
03698 case 2:
03699 v->codingset2 = CS_MID_RATE_INTER;
03700 break;
03701 }
03702
03703 s->first_slice_line = 1;
03704 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
03705 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
03706 ff_init_block_index(s);
03707 ff_update_block_index(s);
03708 s->dsp.clear_blocks(s->block[0]);
03709
03710 vc1_decode_b_mb(v);
03711 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
03712 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
03713 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
03714 return;
03715 }
03716 }
03717 ff_draw_horiz_band(s, s->mb_y * 16, 16);
03718 s->first_slice_line = 0;
03719 }
03720 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
03721 }
03722
03723 static void vc1_decode_skip_blocks(VC1Context *v)
03724 {
03725 MpegEncContext *s = &v->s;
03726
03727 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
03728 s->first_slice_line = 1;
03729 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
03730 s->mb_x = 0;
03731 ff_init_block_index(s);
03732 ff_update_block_index(s);
03733 memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
03734 memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
03735 memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
03736 ff_draw_horiz_band(s, s->mb_y * 16, 16);
03737 s->first_slice_line = 0;
03738 }
03739 s->pict_type = P_TYPE;
03740 }
03741
03742 static void vc1_decode_blocks(VC1Context *v)
03743 {
03744
03745 v->s.esc3_level_length = 0;
03746 if(v->x8_type){
03747 ff_intrax8_decode_picture(&v->x8, 2*v->pq+v->halfpq, v->pq*(!v->pquantizer) );
03748 }else{
03749
03750 switch(v->s.pict_type) {
03751 case I_TYPE:
03752 if(v->profile == PROFILE_ADVANCED)
03753 vc1_decode_i_blocks_adv(v);
03754 else
03755 vc1_decode_i_blocks(v);
03756 break;
03757 case P_TYPE:
03758 if(v->p_frame_skipped)
03759 vc1_decode_skip_blocks(v);
03760 else
03761 vc1_decode_p_blocks(v);
03762 break;
03763 case B_TYPE:
03764 if(v->bi_type){
03765 if(v->profile == PROFILE_ADVANCED)
03766 vc1_decode_i_blocks_adv(v);
03767 else
03768 vc1_decode_i_blocks(v);
03769 }else
03770 vc1_decode_b_blocks(v);
03771 break;
03772 }
03773 }
03774 }
03775
03779 static av_always_inline const uint8_t* find_next_marker(const uint8_t *src, const uint8_t *end)
03780 {
03781 uint32_t mrk = 0xFFFFFFFF;
03782
03783 if(end-src < 4) return end;
03784 while(src < end){
03785 mrk = (mrk << 8) | *src++;
03786 if(IS_MARKER(mrk))
03787 return src-4;
03788 }
03789 return end;
03790 }
03791
03792 static av_always_inline int vc1_unescape_buffer(const uint8_t *src, int size, uint8_t *dst)
03793 {
03794 int dsize = 0, i;
03795
03796 if(size < 4){
03797 for(dsize = 0; dsize < size; dsize++) *dst++ = *src++;
03798 return size;
03799 }
03800 for(i = 0; i < size; i++, src++) {
03801 if(src[0] == 3 && i >= 2 && !src[-1] && !src[-2] && i < size-1 && src[1] < 4) {
03802 dst[dsize++] = src[1];
03803 src++;
03804 i++;
03805 } else
03806 dst[dsize++] = *src;
03807 }
03808 return dsize;
03809 }
03810
03815 static int vc1_decode_init(AVCodecContext *avctx)
03816 {
03817 VC1Context *v = avctx->priv_data;
03818 MpegEncContext *s = &v->s;
03819 GetBitContext gb;
03820
03821 if (!avctx->extradata_size || !avctx->extradata) return -1;
03822 if (!(avctx->flags & CODEC_FLAG_GRAY))
03823 avctx->pix_fmt = PIX_FMT_YUV420P;
03824 else
03825 avctx->pix_fmt = PIX_FMT_GRAY8;
03826 v->s.avctx = avctx;
03827 avctx->flags |= CODEC_FLAG_EMU_EDGE;
03828 v->s.flags |= CODEC_FLAG_EMU_EDGE;
03829
03830 if(avctx->idct_algo==FF_IDCT_AUTO){
03831 avctx->idct_algo=FF_IDCT_WMV2;
03832 }
03833
03834 if(ff_h263_decode_init(avctx) < 0)
03835 return -1;
03836 if (vc1_init_common(v) < 0) return -1;
03837
03838 avctx->coded_width = avctx->width;
03839 avctx->coded_height = avctx->height;
03840 if (avctx->codec_id == CODEC_ID_WMV3)
03841 {
03842 int count = 0;
03843
03844
03845
03846
03847
03848
03849 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
03850
03851 if (decode_sequence_header(avctx, &gb) < 0)
03852 return -1;
03853
03854 count = avctx->extradata_size*8 - get_bits_count(&gb);
03855 if (count>0)
03856 {
03857 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
03858 count, get_bits(&gb, count));
03859 }
03860 else if (count < 0)
03861 {
03862 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
03863 }
03864 } else {
03865 const uint8_t *start = avctx->extradata;
03866 uint8_t *end = avctx->extradata + avctx->extradata_size;
03867 const uint8_t *next;
03868 int size, buf2_size;
03869 uint8_t *buf2 = NULL;
03870 int seq_inited = 0, ep_inited = 0;
03871
03872 if(avctx->extradata_size < 16) {
03873 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
03874 return -1;
03875 }
03876
03877 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
03878 if(start[0]) start++;
03879 next = start;
03880 for(; next < end; start = next){
03881 next = find_next_marker(start + 4, end);
03882 size = next - start - 4;
03883 if(size <= 0) continue;
03884 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
03885 init_get_bits(&gb, buf2, buf2_size * 8);
03886 switch(AV_RB32(start)){
03887 case VC1_CODE_SEQHDR:
03888 if(decode_sequence_header(avctx, &gb) < 0){
03889 av_free(buf2);
03890 return -1;
03891 }
03892 seq_inited = 1;
03893 break;
03894 case VC1_CODE_ENTRYPOINT:
03895 if(decode_entry_point(avctx, &gb) < 0){
03896 av_free(buf2);
03897 return -1;
03898 }
03899 ep_inited = 1;
03900 break;
03901 }
03902 }
03903 av_free(buf2);
03904 if(!seq_inited || !ep_inited){
03905 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
03906 return -1;
03907 }
03908 }
03909 avctx->has_b_frames= !!(avctx->max_b_frames);
03910 s->low_delay = !avctx->has_b_frames;
03911
03912 s->mb_width = (avctx->coded_width+15)>>4;
03913 s->mb_height = (avctx->coded_height+15)>>4;
03914
03915
03916 v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
03917 v->direct_mb_plane = av_malloc(s->mb_stride * s->mb_height);
03918 v->acpred_plane = av_malloc(s->mb_stride * s->mb_height);
03919 v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height);
03920
03921
03922 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
03923 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
03924 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
03925 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
03926
03927
03928 if (v->profile == PROFILE_ADVANCED)
03929 {
03930
03931
03932
03933
03934 }
03935
03936 ff_intrax8_common_init(&v->x8,s);
03937 return 0;
03938 }
03939
03940
03944 static int vc1_decode_frame(AVCodecContext *avctx,
03945 void *data, int *data_size,
03946 const uint8_t *buf, int buf_size)
03947 {
03948 VC1Context *v = avctx->priv_data;
03949 MpegEncContext *s = &v->s;
03950 AVFrame *pict = data;
03951 uint8_t *buf2 = NULL;
03952
03953
03954 if (buf_size == 0) {
03955
03956 if (s->low_delay==0 && s->next_picture_ptr) {
03957 *pict= *(AVFrame*)s->next_picture_ptr;
03958 s->next_picture_ptr= NULL;
03959
03960 *data_size = sizeof(AVFrame);
03961 }
03962
03963 return 0;
03964 }
03965
03966
03967
03968 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
03969 int i= ff_find_unused_picture(s, 0);
03970 s->current_picture_ptr= &s->picture[i];
03971 }
03972
03973
03974 if (avctx->codec_id == CODEC_ID_VC1) {
03975 int buf_size2 = 0;
03976 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
03977
03978 if(IS_MARKER(AV_RB32(buf))){
03979 const uint8_t *start, *end, *next;
03980 int size;
03981
03982 next = buf;
03983 for(start = buf, end = buf + buf_size; next < end; start = next){
03984 next = find_next_marker(start + 4, end);
03985 size = next - start - 4;
03986 if(size <= 0) continue;
03987 switch(AV_RB32(start)){
03988 case VC1_CODE_FRAME:
03989 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
03990 break;
03991 case VC1_CODE_ENTRYPOINT:
03992 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
03993 init_get_bits(&s->gb, buf2, buf_size2*8);
03994 decode_entry_point(avctx, &s->gb);
03995 break;
03996 case VC1_CODE_SLICE:
03997 av_log(avctx, AV_LOG_ERROR, "Sliced decoding is not implemented (yet)\n");
03998 av_free(buf2);
03999 return -1;
04000 }
04001 }
04002 }else if(v->interlace && ((buf[0] & 0xC0) == 0xC0)){
04003 const uint8_t *divider;
04004
04005 divider = find_next_marker(buf, buf + buf_size);
04006 if((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD){
04007 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
04008 return -1;
04009 }
04010
04011 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
04012
04013 av_free(buf2);return -1;
04014 }else{
04015 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
04016 }
04017 init_get_bits(&s->gb, buf2, buf_size2*8);
04018 } else
04019 init_get_bits(&s->gb, buf, buf_size*8);
04020
04021 if(v->profile < PROFILE_ADVANCED) {
04022 if(vc1_parse_frame_header(v, &s->gb) == -1) {
04023 av_free(buf2);
04024 return -1;
04025 }
04026 } else {
04027 if(vc1_parse_frame_header_adv(v, &s->gb) == -1) {
04028 av_free(buf2);
04029 return -1;
04030 }
04031 }
04032
04033 if(s->pict_type != I_TYPE && !v->res_rtm_flag){
04034 av_free(buf2);
04035 return -1;
04036 }
04037
04038
04039 s->current_picture.pict_type= s->pict_type;
04040 s->current_picture.key_frame= s->pict_type == I_TYPE;
04041
04042
04043 if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)){
04044 av_free(buf2);
04045 return -1;
04046 }
04047
04048 if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;
04049 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
04050 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
04051 || avctx->skip_frame >= AVDISCARD_ALL) {
04052 av_free(buf2);
04053 return buf_size;
04054 }
04055
04056 if(avctx->hurry_up>=5) {
04057 av_free(buf2);
04058 return -1;
04059 }
04060
04061 if(s->next_p_frame_damaged){
04062 if(s->pict_type==B_TYPE)
04063 return buf_size;
04064 else
04065 s->next_p_frame_damaged=0;
04066 }
04067
04068 if(MPV_frame_start(s, avctx) < 0) {
04069 av_free(buf2);
04070 return -1;
04071 }
04072
04073 s->me.qpel_put= s->dsp.put_qpel_pixels_tab;
04074 s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
04075
04076 ff_er_frame_start(s);
04077
04078 v->bits = buf_size * 8;
04079 vc1_decode_blocks(v);
04080
04081
04082
04083 ff_er_frame_end(s);
04084
04085 MPV_frame_end(s);
04086
04087 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
04088 assert(s->current_picture.pict_type == s->pict_type);
04089 if (s->pict_type == B_TYPE || s->low_delay) {
04090 *pict= *(AVFrame*)s->current_picture_ptr;
04091 } else if (s->last_picture_ptr != NULL) {
04092 *pict= *(AVFrame*)s->last_picture_ptr;
04093 }
04094
04095 if(s->last_picture_ptr || s->low_delay){
04096 *data_size = sizeof(AVFrame);
04097 ff_print_debug_info(s, pict);
04098 }
04099
04100
04101
04102 avctx->frame_number = s->picture_number - 1;
04103
04104 av_free(buf2);
04105 return buf_size;
04106 }
04107
04108
04112 static int vc1_decode_end(AVCodecContext *avctx)
04113 {
04114 VC1Context *v = avctx->priv_data;
04115
04116 av_freep(&v->hrd_rate);
04117 av_freep(&v->hrd_buffer);
04118 MPV_common_end(&v->s);
04119 av_freep(&v->mv_type_mb_plane);
04120 av_freep(&v->direct_mb_plane);
04121 av_freep(&v->acpred_plane);
04122 av_freep(&v->over_flags_plane);
04123 av_freep(&v->mb_type_base);
04124 ff_intrax8_common_end(&v->x8);
04125 return 0;
04126 }
04127
04128
04129 AVCodec vc1_decoder = {
04130 "vc1",
04131 CODEC_TYPE_VIDEO,
04132 CODEC_ID_VC1,
04133 sizeof(VC1Context),
04134 vc1_decode_init,
04135 NULL,
04136 vc1_decode_end,
04137 vc1_decode_frame,
04138 CODEC_CAP_DELAY,
04139 NULL
04140 };
04141
04142 AVCodec wmv3_decoder = {
04143 "wmv3",
04144 CODEC_TYPE_VIDEO,
04145 CODEC_ID_WMV3,
04146 sizeof(VC1Context),
04147 vc1_decode_init,
04148 NULL,
04149 vc1_decode_end,
04150 vc1_decode_frame,
04151 CODEC_CAP_DELAY,
04152 NULL
04153 };