00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00028 #include "internal.h"
00029 #include "dsputil.h"
00030 #include "avcodec.h"
00031 #include "mpegvideo.h"
00032 #include "h263.h"
00033 #include "vc1.h"
00034 #include "vc1data.h"
00035 #include "vc1acdata.h"
00036 #include "msmpeg4data.h"
00037 #include "unary.h"
00038 #include "simple_idct.h"
00039 #include "mathops.h"
00040 #include "vdpau_internal.h"
00041
00042 #undef NDEBUG
00043 #include <assert.h>
00044
00045 #define MB_INTRA_VLC_BITS 9
00046 #define DC_VLC_BITS 9
00047 #define AC_VLC_BITS 9
00048 static const uint16_t table_mb_intra[64][2];
00049
00050
00051 static const uint16_t vlc_offs[] = {
00052 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
00053 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8620,
00054 9262, 10202, 10756, 11310, 12228, 15078
00055 };
00056
00062 static int vc1_init_common(VC1Context *v)
00063 {
00064 static int done = 0;
00065 int i = 0;
00066 static VLC_TYPE vlc_table[15078][2];
00067
00068 v->hrd_rate = v->hrd_buffer = NULL;
00069
00070
00071 if(!done)
00072 {
00073 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
00074 ff_vc1_bfraction_bits, 1, 1,
00075 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
00076 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
00077 ff_vc1_norm2_bits, 1, 1,
00078 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
00079 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
00080 ff_vc1_norm6_bits, 1, 1,
00081 ff_vc1_norm6_codes, 2, 2, 556);
00082 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
00083 ff_vc1_imode_bits, 1, 1,
00084 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
00085 for (i=0; i<3; i++)
00086 {
00087 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i*3+0]];
00088 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i*3+1] - vlc_offs[i*3+0];
00089 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
00090 ff_vc1_ttmb_bits[i], 1, 1,
00091 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00092 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i*3+1]];
00093 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i*3+2] - vlc_offs[i*3+1];
00094 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
00095 ff_vc1_ttblk_bits[i], 1, 1,
00096 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00097 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i*3+2]];
00098 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i*3+3] - vlc_offs[i*3+2];
00099 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
00100 ff_vc1_subblkpat_bits[i], 1, 1,
00101 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00102 }
00103 for(i=0; i<4; i++)
00104 {
00105 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i*3+9]];
00106 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i*3+10] - vlc_offs[i*3+9];
00107 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
00108 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
00109 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00110 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i*3+10]];
00111 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i*3+11] - vlc_offs[i*3+10];
00112 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
00113 ff_vc1_cbpcy_p_bits[i], 1, 1,
00114 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00115 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i*3+11]];
00116 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i*3+12] - vlc_offs[i*3+11];
00117 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
00118 ff_vc1_mv_diff_bits[i], 1, 1,
00119 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00120 }
00121 for(i=0; i<8; i++){
00122 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i+21]];
00123 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i+22] - vlc_offs[i+21];
00124 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
00125 &vc1_ac_tables[i][0][1], 8, 4,
00126 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
00127 }
00128 done = 1;
00129 }
00130
00131
00132 v->pq = -1;
00133 v->mvrange = 0;
00134
00135 return 0;
00136 }
00137
00138
00149 enum Imode {
00150 IMODE_RAW,
00151 IMODE_NORM2,
00152 IMODE_DIFF2,
00153 IMODE_NORM6,
00154 IMODE_DIFF6,
00155 IMODE_ROWSKIP,
00156 IMODE_COLSKIP
00157 };
00159
00160
00162
00163 static void vc1_loop_filter_iblk(MpegEncContext *s, int pq)
00164 {
00165 int j;
00166 if (!s->first_slice_line) {
00167 s->dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
00168 if (s->mb_x)
00169 s->dsp.vc1_h_loop_filter16(s->dest[0] - 16*s->linesize, s->linesize, pq);
00170 s->dsp.vc1_h_loop_filter16(s->dest[0] - 16*s->linesize+8, s->linesize, pq);
00171 for(j = 0; j < 2; j++){
00172 s->dsp.vc1_v_loop_filter8(s->dest[j+1], s->uvlinesize, pq);
00173 if (s->mb_x)
00174 s->dsp.vc1_h_loop_filter8(s->dest[j+1]-8*s->uvlinesize, s->uvlinesize, pq);
00175 }
00176 }
00177 s->dsp.vc1_v_loop_filter16(s->dest[0] + 8*s->linesize, s->linesize, pq);
00178
00179 if (s->mb_y == s->mb_height-1) {
00180 if (s->mb_x) {
00181 s->dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
00182 s->dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
00183 s->dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
00184 }
00185 s->dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
00186 }
00187 }
00188
00191 static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
00192 {
00193 uint8_t *Y;
00194 int ys, us, vs;
00195 DSPContext *dsp = &v->s.dsp;
00196
00197 if(v->rangeredfrm) {
00198 int i, j, k;
00199 for(k = 0; k < 6; k++)
00200 for(j = 0; j < 8; j++)
00201 for(i = 0; i < 8; i++)
00202 block[k][i + j*8] = ((block[k][i + j*8] - 128) << 1) + 128;
00203
00204 }
00205 ys = v->s.current_picture.linesize[0];
00206 us = v->s.current_picture.linesize[1];
00207 vs = v->s.current_picture.linesize[2];
00208 Y = v->s.dest[0];
00209
00210 dsp->put_pixels_clamped(block[0], Y, ys);
00211 dsp->put_pixels_clamped(block[1], Y + 8, ys);
00212 Y += ys * 8;
00213 dsp->put_pixels_clamped(block[2], Y, ys);
00214 dsp->put_pixels_clamped(block[3], Y + 8, ys);
00215
00216 if(!(v->s.flags & CODEC_FLAG_GRAY)) {
00217 dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
00218 dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
00219 }
00220 }
00221
00225 static void vc1_mc_1mv(VC1Context *v, int dir)
00226 {
00227 MpegEncContext *s = &v->s;
00228 DSPContext *dsp = &v->s.dsp;
00229 uint8_t *srcY, *srcU, *srcV;
00230 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
00231
00232 if(!v->s.last_picture.data[0])return;
00233
00234 mx = s->mv[dir][0][0];
00235 my = s->mv[dir][0][1];
00236
00237
00238 if(s->pict_type == FF_P_TYPE) {
00239 s->current_picture.motion_val[1][s->block_index[0]][0] = mx;
00240 s->current_picture.motion_val[1][s->block_index[0]][1] = my;
00241 }
00242 uvmx = (mx + ((mx & 3) == 3)) >> 1;
00243 uvmy = (my + ((my & 3) == 3)) >> 1;
00244 if(v->fastuvmc) {
00245 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
00246 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
00247 }
00248 if(!dir) {
00249 srcY = s->last_picture.data[0];
00250 srcU = s->last_picture.data[1];
00251 srcV = s->last_picture.data[2];
00252 } else {
00253 srcY = s->next_picture.data[0];
00254 srcU = s->next_picture.data[1];
00255 srcV = s->next_picture.data[2];
00256 }
00257
00258 src_x = s->mb_x * 16 + (mx >> 2);
00259 src_y = s->mb_y * 16 + (my >> 2);
00260 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00261 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00262
00263 if(v->profile != PROFILE_ADVANCED){
00264 src_x = av_clip( src_x, -16, s->mb_width * 16);
00265 src_y = av_clip( src_y, -16, s->mb_height * 16);
00266 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
00267 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00268 }else{
00269 src_x = av_clip( src_x, -17, s->avctx->coded_width);
00270 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
00271 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
00272 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00273 }
00274
00275 srcY += src_y * s->linesize + src_x;
00276 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
00277 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
00278
00279
00280 if(s->flags & CODEC_FLAG_GRAY) {
00281 srcU = s->edge_emu_buffer + 18 * s->linesize;
00282 srcV = s->edge_emu_buffer + 18 * s->linesize;
00283 }
00284
00285 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00286 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
00287 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
00288 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
00289
00290 srcY -= s->mspel * (1 + s->linesize);
00291 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
00292 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
00293 srcY = s->edge_emu_buffer;
00294 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
00295 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00296 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
00297 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00298 srcU = uvbuf;
00299 srcV = uvbuf + 16;
00300
00301 if(v->rangeredfrm) {
00302 int i, j;
00303 uint8_t *src, *src2;
00304
00305 src = srcY;
00306 for(j = 0; j < 17 + s->mspel*2; j++) {
00307 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
00308 src += s->linesize;
00309 }
00310 src = srcU; src2 = srcV;
00311 for(j = 0; j < 9; j++) {
00312 for(i = 0; i < 9; i++) {
00313 src[i] = ((src[i] - 128) >> 1) + 128;
00314 src2[i] = ((src2[i] - 128) >> 1) + 128;
00315 }
00316 src += s->uvlinesize;
00317 src2 += s->uvlinesize;
00318 }
00319 }
00320
00321 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00322 int i, j;
00323 uint8_t *src, *src2;
00324
00325 src = srcY;
00326 for(j = 0; j < 17 + s->mspel*2; j++) {
00327 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
00328 src += s->linesize;
00329 }
00330 src = srcU; src2 = srcV;
00331 for(j = 0; j < 9; j++) {
00332 for(i = 0; i < 9; i++) {
00333 src[i] = v->lutuv[src[i]];
00334 src2[i] = v->lutuv[src2[i]];
00335 }
00336 src += s->uvlinesize;
00337 src2 += s->uvlinesize;
00338 }
00339 }
00340 srcY += s->mspel * (1 + s->linesize);
00341 }
00342
00343 if(s->mspel) {
00344 dxy = ((my & 3) << 2) | (mx & 3);
00345 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
00346 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
00347 srcY += s->linesize * 8;
00348 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
00349 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
00350 } else {
00351 dxy = (my & 2) | ((mx & 2) >> 1);
00352
00353 if(!v->rnd)
00354 dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00355 else
00356 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00357 }
00358
00359 if(s->flags & CODEC_FLAG_GRAY) return;
00360
00361 uvmx = (uvmx&3)<<1;
00362 uvmy = (uvmy&3)<<1;
00363 if(!v->rnd){
00364 dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00365 dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00366 }else{
00367 dsp->put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00368 dsp->put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00369 }
00370 }
00371
00374 static void vc1_mc_4mv_luma(VC1Context *v, int n)
00375 {
00376 MpegEncContext *s = &v->s;
00377 DSPContext *dsp = &v->s.dsp;
00378 uint8_t *srcY;
00379 int dxy, mx, my, src_x, src_y;
00380 int off;
00381
00382 if(!v->s.last_picture.data[0])return;
00383 mx = s->mv[0][n][0];
00384 my = s->mv[0][n][1];
00385 srcY = s->last_picture.data[0];
00386
00387 off = s->linesize * 4 * (n&2) + (n&1) * 8;
00388
00389 src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
00390 src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
00391
00392 if(v->profile != PROFILE_ADVANCED){
00393 src_x = av_clip( src_x, -16, s->mb_width * 16);
00394 src_y = av_clip( src_y, -16, s->mb_height * 16);
00395 }else{
00396 src_x = av_clip( src_x, -17, s->avctx->coded_width);
00397 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
00398 }
00399
00400 srcY += src_y * s->linesize + src_x;
00401
00402 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00403 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
00404 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
00405 srcY -= s->mspel * (1 + s->linesize);
00406 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
00407 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
00408 srcY = s->edge_emu_buffer;
00409
00410 if(v->rangeredfrm) {
00411 int i, j;
00412 uint8_t *src;
00413
00414 src = srcY;
00415 for(j = 0; j < 9 + s->mspel*2; j++) {
00416 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
00417 src += s->linesize;
00418 }
00419 }
00420
00421 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00422 int i, j;
00423 uint8_t *src;
00424
00425 src = srcY;
00426 for(j = 0; j < 9 + s->mspel*2; j++) {
00427 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
00428 src += s->linesize;
00429 }
00430 }
00431 srcY += s->mspel * (1 + s->linesize);
00432 }
00433
00434 if(s->mspel) {
00435 dxy = ((my & 3) << 2) | (mx & 3);
00436 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
00437 } else {
00438 dxy = (my & 2) | ((mx & 2) >> 1);
00439 if(!v->rnd)
00440 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00441 else
00442 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00443 }
00444 }
00445
00446 static inline int median4(int a, int b, int c, int d)
00447 {
00448 if(a < b) {
00449 if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
00450 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
00451 } else {
00452 if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
00453 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
00454 }
00455 }
00456
00457
00460 static void vc1_mc_4mv_chroma(VC1Context *v)
00461 {
00462 MpegEncContext *s = &v->s;
00463 DSPContext *dsp = &v->s.dsp;
00464 uint8_t *srcU, *srcV;
00465 int uvmx, uvmy, uvsrc_x, uvsrc_y;
00466 int i, idx, tx = 0, ty = 0;
00467 int mvx[4], mvy[4], intra[4];
00468 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
00469
00470 if(!v->s.last_picture.data[0])return;
00471 if(s->flags & CODEC_FLAG_GRAY) return;
00472
00473 for(i = 0; i < 4; i++) {
00474 mvx[i] = s->mv[0][i][0];
00475 mvy[i] = s->mv[0][i][1];
00476 intra[i] = v->mb_type[0][s->block_index[i]];
00477 }
00478
00479
00480 idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
00481 if(!idx) {
00482 tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
00483 ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
00484 } else if(count[idx] == 1) {
00485 switch(idx) {
00486 case 0x1:
00487 tx = mid_pred(mvx[1], mvx[2], mvx[3]);
00488 ty = mid_pred(mvy[1], mvy[2], mvy[3]);
00489 break;
00490 case 0x2:
00491 tx = mid_pred(mvx[0], mvx[2], mvx[3]);
00492 ty = mid_pred(mvy[0], mvy[2], mvy[3]);
00493 break;
00494 case 0x4:
00495 tx = mid_pred(mvx[0], mvx[1], mvx[3]);
00496 ty = mid_pred(mvy[0], mvy[1], mvy[3]);
00497 break;
00498 case 0x8:
00499 tx = mid_pred(mvx[0], mvx[1], mvx[2]);
00500 ty = mid_pred(mvy[0], mvy[1], mvy[2]);
00501 break;
00502 }
00503 } else if(count[idx] == 2) {
00504 int t1 = 0, t2 = 0;
00505 for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
00506 for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
00507 tx = (mvx[t1] + mvx[t2]) / 2;
00508 ty = (mvy[t1] + mvy[t2]) / 2;
00509 } else {
00510 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
00511 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
00512 return;
00513 }
00514
00515 s->current_picture.motion_val[1][s->block_index[0]][0] = tx;
00516 s->current_picture.motion_val[1][s->block_index[0]][1] = ty;
00517 uvmx = (tx + ((tx&3) == 3)) >> 1;
00518 uvmy = (ty + ((ty&3) == 3)) >> 1;
00519 if(v->fastuvmc) {
00520 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
00521 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
00522 }
00523
00524 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00525 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00526
00527 if(v->profile != PROFILE_ADVANCED){
00528 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
00529 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00530 }else{
00531 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
00532 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00533 }
00534
00535 srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00536 srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00537 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00538 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
00539 || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
00540 ff_emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize, 8+1, 8+1,
00541 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00542 ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
00543 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00544 srcU = s->edge_emu_buffer;
00545 srcV = s->edge_emu_buffer + 16;
00546
00547
00548 if(v->rangeredfrm) {
00549 int i, j;
00550 uint8_t *src, *src2;
00551
00552 src = srcU; src2 = srcV;
00553 for(j = 0; j < 9; j++) {
00554 for(i = 0; i < 9; i++) {
00555 src[i] = ((src[i] - 128) >> 1) + 128;
00556 src2[i] = ((src2[i] - 128) >> 1) + 128;
00557 }
00558 src += s->uvlinesize;
00559 src2 += s->uvlinesize;
00560 }
00561 }
00562
00563 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00564 int i, j;
00565 uint8_t *src, *src2;
00566
00567 src = srcU; src2 = srcV;
00568 for(j = 0; j < 9; j++) {
00569 for(i = 0; i < 9; i++) {
00570 src[i] = v->lutuv[src[i]];
00571 src2[i] = v->lutuv[src2[i]];
00572 }
00573 src += s->uvlinesize;
00574 src2 += s->uvlinesize;
00575 }
00576 }
00577 }
00578
00579
00580 uvmx = (uvmx&3)<<1;
00581 uvmy = (uvmy&3)<<1;
00582 if(!v->rnd){
00583 dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00584 dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00585 }else{
00586 dsp->put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00587 dsp->put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00588 }
00589 }
00590
00591
00602 #define GET_MQUANT() \
00603 if (v->dquantfrm) \
00604 { \
00605 int edges = 0; \
00606 if (v->dqprofile == DQPROFILE_ALL_MBS) \
00607 { \
00608 if (v->dqbilevel) \
00609 { \
00610 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
00611 } \
00612 else \
00613 { \
00614 mqdiff = get_bits(gb, 3); \
00615 if (mqdiff != 7) mquant = v->pq + mqdiff; \
00616 else mquant = get_bits(gb, 5); \
00617 } \
00618 } \
00619 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
00620 edges = 1 << v->dqsbedge; \
00621 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
00622 edges = (3 << v->dqsbedge) % 15; \
00623 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
00624 edges = 15; \
00625 if((edges&1) && !s->mb_x) \
00626 mquant = v->altpq; \
00627 if((edges&2) && s->first_slice_line) \
00628 mquant = v->altpq; \
00629 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
00630 mquant = v->altpq; \
00631 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
00632 mquant = v->altpq; \
00633 }
00634
00642 #define GET_MVDATA(_dmv_x, _dmv_y) \
00643 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table,\
00644 VC1_MV_DIFF_VLC_BITS, 2); \
00645 if (index > 36) \
00646 { \
00647 mb_has_coeffs = 1; \
00648 index -= 37; \
00649 } \
00650 else mb_has_coeffs = 0; \
00651 s->mb_intra = 0; \
00652 if (!index) { _dmv_x = _dmv_y = 0; } \
00653 else if (index == 35) \
00654 { \
00655 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
00656 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
00657 } \
00658 else if (index == 36) \
00659 { \
00660 _dmv_x = 0; \
00661 _dmv_y = 0; \
00662 s->mb_intra = 1; \
00663 } \
00664 else \
00665 { \
00666 index1 = index%6; \
00667 if (!s->quarter_sample && index1 == 5) val = 1; \
00668 else val = 0; \
00669 if(size_table[index1] - val > 0) \
00670 val = get_bits(gb, size_table[index1] - val); \
00671 else val = 0; \
00672 sign = 0 - (val&1); \
00673 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
00674 \
00675 index1 = index/6; \
00676 if (!s->quarter_sample && index1 == 5) val = 1; \
00677 else val = 0; \
00678 if(size_table[index1] - val > 0) \
00679 val = get_bits(gb, size_table[index1] - val); \
00680 else val = 0; \
00681 sign = 0 - (val&1); \
00682 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
00683 }
00684
00687 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)
00688 {
00689 int xy, wrap, off = 0;
00690 int16_t *A, *B, *C;
00691 int px, py;
00692 int sum;
00693
00694
00695 dmv_x <<= 1 - s->quarter_sample;
00696 dmv_y <<= 1 - s->quarter_sample;
00697
00698 wrap = s->b8_stride;
00699 xy = s->block_index[n];
00700
00701 if(s->mb_intra){
00702 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
00703 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
00704 s->current_picture.motion_val[1][xy][0] = 0;
00705 s->current_picture.motion_val[1][xy][1] = 0;
00706 if(mv1) {
00707 s->current_picture.motion_val[0][xy + 1][0] = 0;
00708 s->current_picture.motion_val[0][xy + 1][1] = 0;
00709 s->current_picture.motion_val[0][xy + wrap][0] = 0;
00710 s->current_picture.motion_val[0][xy + wrap][1] = 0;
00711 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
00712 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
00713 s->current_picture.motion_val[1][xy + 1][0] = 0;
00714 s->current_picture.motion_val[1][xy + 1][1] = 0;
00715 s->current_picture.motion_val[1][xy + wrap][0] = 0;
00716 s->current_picture.motion_val[1][xy + wrap][1] = 0;
00717 s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
00718 s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
00719 }
00720 return;
00721 }
00722
00723 C = s->current_picture.motion_val[0][xy - 1];
00724 A = s->current_picture.motion_val[0][xy - wrap];
00725 if(mv1)
00726 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
00727 else {
00728
00729 switch(n){
00730 case 0:
00731 off = (s->mb_x > 0) ? -1 : 1;
00732 break;
00733 case 1:
00734 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
00735 break;
00736 case 2:
00737 off = 1;
00738 break;
00739 case 3:
00740 off = -1;
00741 }
00742 }
00743 B = s->current_picture.motion_val[0][xy - wrap + off];
00744
00745 if(!s->first_slice_line || (n==2 || n==3)) {
00746 if(s->mb_width == 1) {
00747 px = A[0];
00748 py = A[1];
00749 } else {
00750 px = mid_pred(A[0], B[0], C[0]);
00751 py = mid_pred(A[1], B[1], C[1]);
00752 }
00753 } else if(s->mb_x || (n==1 || n==3)) {
00754 px = C[0];
00755 py = C[1];
00756 } else {
00757 px = py = 0;
00758 }
00759
00760 {
00761 int qx, qy, X, Y;
00762 qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
00763 qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
00764 X = (s->mb_width << 6) - 4;
00765 Y = (s->mb_height << 6) - 4;
00766 if(mv1) {
00767 if(qx + px < -60) px = -60 - qx;
00768 if(qy + py < -60) py = -60 - qy;
00769 } else {
00770 if(qx + px < -28) px = -28 - qx;
00771 if(qy + py < -28) py = -28 - qy;
00772 }
00773 if(qx + px > X) px = X - qx;
00774 if(qy + py > Y) py = Y - qy;
00775 }
00776
00777 if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
00778 if(is_intra[xy - wrap])
00779 sum = FFABS(px) + FFABS(py);
00780 else
00781 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
00782 if(sum > 32) {
00783 if(get_bits1(&s->gb)) {
00784 px = A[0];
00785 py = A[1];
00786 } else {
00787 px = C[0];
00788 py = C[1];
00789 }
00790 } else {
00791 if(is_intra[xy - 1])
00792 sum = FFABS(px) + FFABS(py);
00793 else
00794 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
00795 if(sum > 32) {
00796 if(get_bits1(&s->gb)) {
00797 px = A[0];
00798 py = A[1];
00799 } else {
00800 px = C[0];
00801 py = C[1];
00802 }
00803 }
00804 }
00805 }
00806
00807 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
00808 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
00809 if(mv1) {
00810 s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
00811 s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
00812 s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
00813 s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
00814 s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
00815 s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
00816 }
00817 }
00818
00821 static void vc1_interp_mc(VC1Context *v)
00822 {
00823 MpegEncContext *s = &v->s;
00824 DSPContext *dsp = &v->s.dsp;
00825 uint8_t *srcY, *srcU, *srcV;
00826 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
00827
00828 if(!v->s.next_picture.data[0])return;
00829
00830 mx = s->mv[1][0][0];
00831 my = s->mv[1][0][1];
00832 uvmx = (mx + ((mx & 3) == 3)) >> 1;
00833 uvmy = (my + ((my & 3) == 3)) >> 1;
00834 if(v->fastuvmc) {
00835 uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
00836 uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
00837 }
00838 srcY = s->next_picture.data[0];
00839 srcU = s->next_picture.data[1];
00840 srcV = s->next_picture.data[2];
00841
00842 src_x = s->mb_x * 16 + (mx >> 2);
00843 src_y = s->mb_y * 16 + (my >> 2);
00844 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00845 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00846
00847 if(v->profile != PROFILE_ADVANCED){
00848 src_x = av_clip( src_x, -16, s->mb_width * 16);
00849 src_y = av_clip( src_y, -16, s->mb_height * 16);
00850 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
00851 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00852 }else{
00853 src_x = av_clip( src_x, -17, s->avctx->coded_width);
00854 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
00855 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
00856 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00857 }
00858
00859 srcY += src_y * s->linesize + src_x;
00860 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
00861 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
00862
00863
00864 if(s->flags & CODEC_FLAG_GRAY) {
00865 srcU = s->edge_emu_buffer + 18 * s->linesize;
00866 srcV = s->edge_emu_buffer + 18 * s->linesize;
00867 }
00868
00869 if(v->rangeredfrm
00870 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
00871 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
00872 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
00873
00874 srcY -= s->mspel * (1 + s->linesize);
00875 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
00876 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
00877 srcY = s->edge_emu_buffer;
00878 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
00879 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00880 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
00881 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00882 srcU = uvbuf;
00883 srcV = uvbuf + 16;
00884
00885 if(v->rangeredfrm) {
00886 int i, j;
00887 uint8_t *src, *src2;
00888
00889 src = srcY;
00890 for(j = 0; j < 17 + s->mspel*2; j++) {
00891 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
00892 src += s->linesize;
00893 }
00894 src = srcU; src2 = srcV;
00895 for(j = 0; j < 9; j++) {
00896 for(i = 0; i < 9; i++) {
00897 src[i] = ((src[i] - 128) >> 1) + 128;
00898 src2[i] = ((src2[i] - 128) >> 1) + 128;
00899 }
00900 src += s->uvlinesize;
00901 src2 += s->uvlinesize;
00902 }
00903 }
00904 srcY += s->mspel * (1 + s->linesize);
00905 }
00906
00907 if(s->mspel) {
00908 dxy = ((my & 3) << 2) | (mx & 3);
00909 dsp->avg_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
00910 dsp->avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
00911 srcY += s->linesize * 8;
00912 dsp->avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
00913 dsp->avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
00914 } else {
00915 dxy = (my & 2) | ((mx & 2) >> 1);
00916
00917 if(!v->rnd)
00918 dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00919 else
00920 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00921 }
00922
00923 if(s->flags & CODEC_FLAG_GRAY) return;
00924
00925 uvmx = (uvmx&3)<<1;
00926 uvmy = (uvmy&3)<<1;
00927 if(!v->rnd){
00928 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00929 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00930 }else{
00931 dsp->avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00932 dsp->avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00933 }
00934 }
00935
00936 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
00937 {
00938 int n = bfrac;
00939
00940 #if B_FRACTION_DEN==256
00941 if(inv)
00942 n -= 256;
00943 if(!qs)
00944 return 2 * ((value * n + 255) >> 9);
00945 return (value * n + 128) >> 8;
00946 #else
00947 if(inv)
00948 n -= B_FRACTION_DEN;
00949 if(!qs)
00950 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
00951 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
00952 #endif
00953 }
00954
00957 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
00958 {
00959 if(v->use_ic) {
00960 v->mv_mode2 = v->mv_mode;
00961 v->mv_mode = MV_PMODE_INTENSITY_COMP;
00962 }
00963 if(direct) {
00964 vc1_mc_1mv(v, 0);
00965 vc1_interp_mc(v);
00966 if(v->use_ic) v->mv_mode = v->mv_mode2;
00967 return;
00968 }
00969 if(mode == BMV_TYPE_INTERPOLATED) {
00970 vc1_mc_1mv(v, 0);
00971 vc1_interp_mc(v);
00972 if(v->use_ic) v->mv_mode = v->mv_mode2;
00973 return;
00974 }
00975
00976 if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
00977 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
00978 if(v->use_ic) v->mv_mode = v->mv_mode2;
00979 }
00980
00981 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
00982 {
00983 MpegEncContext *s = &v->s;
00984 int xy, wrap, off = 0;
00985 int16_t *A, *B, *C;
00986 int px, py;
00987 int sum;
00988 int r_x, r_y;
00989 const uint8_t *is_intra = v->mb_type[0];
00990
00991 r_x = v->range_x;
00992 r_y = v->range_y;
00993
00994 dmv_x[0] <<= 1 - s->quarter_sample;
00995 dmv_y[0] <<= 1 - s->quarter_sample;
00996 dmv_x[1] <<= 1 - s->quarter_sample;
00997 dmv_y[1] <<= 1 - s->quarter_sample;
00998
00999 wrap = s->b8_stride;
01000 xy = s->block_index[0];
01001
01002 if(s->mb_intra) {
01003 s->current_picture.motion_val[0][xy][0] =
01004 s->current_picture.motion_val[0][xy][1] =
01005 s->current_picture.motion_val[1][xy][0] =
01006 s->current_picture.motion_val[1][xy][1] = 0;
01007 return;
01008 }
01009 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
01010 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
01011 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
01012 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
01013
01014
01015 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));
01016 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));
01017 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));
01018 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));
01019 if(direct) {
01020 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
01021 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
01022 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
01023 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
01024 return;
01025 }
01026
01027 if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
01028 C = s->current_picture.motion_val[0][xy - 2];
01029 A = s->current_picture.motion_val[0][xy - wrap*2];
01030 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
01031 B = s->current_picture.motion_val[0][xy - wrap*2 + off];
01032
01033 if(!s->mb_x) C[0] = C[1] = 0;
01034 if(!s->first_slice_line) {
01035 if(s->mb_width == 1) {
01036 px = A[0];
01037 py = A[1];
01038 } else {
01039 px = mid_pred(A[0], B[0], C[0]);
01040 py = mid_pred(A[1], B[1], C[1]);
01041 }
01042 } else if(s->mb_x) {
01043 px = C[0];
01044 py = C[1];
01045 } else {
01046 px = py = 0;
01047 }
01048
01049 {
01050 int qx, qy, X, Y;
01051 if(v->profile < PROFILE_ADVANCED) {
01052 qx = (s->mb_x << 5);
01053 qy = (s->mb_y << 5);
01054 X = (s->mb_width << 5) - 4;
01055 Y = (s->mb_height << 5) - 4;
01056 if(qx + px < -28) px = -28 - qx;
01057 if(qy + py < -28) py = -28 - qy;
01058 if(qx + px > X) px = X - qx;
01059 if(qy + py > Y) py = Y - qy;
01060 } else {
01061 qx = (s->mb_x << 6);
01062 qy = (s->mb_y << 6);
01063 X = (s->mb_width << 6) - 4;
01064 Y = (s->mb_height << 6) - 4;
01065 if(qx + px < -60) px = -60 - qx;
01066 if(qy + py < -60) py = -60 - qy;
01067 if(qx + px > X) px = X - qx;
01068 if(qy + py > Y) py = Y - qy;
01069 }
01070 }
01071
01072 if(0 && !s->first_slice_line && s->mb_x) {
01073 if(is_intra[xy - wrap])
01074 sum = FFABS(px) + FFABS(py);
01075 else
01076 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
01077 if(sum > 32) {
01078 if(get_bits1(&s->gb)) {
01079 px = A[0];
01080 py = A[1];
01081 } else {
01082 px = C[0];
01083 py = C[1];
01084 }
01085 } else {
01086 if(is_intra[xy - 2])
01087 sum = FFABS(px) + FFABS(py);
01088 else
01089 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
01090 if(sum > 32) {
01091 if(get_bits1(&s->gb)) {
01092 px = A[0];
01093 py = A[1];
01094 } else {
01095 px = C[0];
01096 py = C[1];
01097 }
01098 }
01099 }
01100 }
01101
01102 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
01103 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
01104 }
01105 if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
01106 C = s->current_picture.motion_val[1][xy - 2];
01107 A = s->current_picture.motion_val[1][xy - wrap*2];
01108 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
01109 B = s->current_picture.motion_val[1][xy - wrap*2 + off];
01110
01111 if(!s->mb_x) C[0] = C[1] = 0;
01112 if(!s->first_slice_line) {
01113 if(s->mb_width == 1) {
01114 px = A[0];
01115 py = A[1];
01116 } else {
01117 px = mid_pred(A[0], B[0], C[0]);
01118 py = mid_pred(A[1], B[1], C[1]);
01119 }
01120 } else if(s->mb_x) {
01121 px = C[0];
01122 py = C[1];
01123 } else {
01124 px = py = 0;
01125 }
01126
01127 {
01128 int qx, qy, X, Y;
01129 if(v->profile < PROFILE_ADVANCED) {
01130 qx = (s->mb_x << 5);
01131 qy = (s->mb_y << 5);
01132 X = (s->mb_width << 5) - 4;
01133 Y = (s->mb_height << 5) - 4;
01134 if(qx + px < -28) px = -28 - qx;
01135 if(qy + py < -28) py = -28 - qy;
01136 if(qx + px > X) px = X - qx;
01137 if(qy + py > Y) py = Y - qy;
01138 } else {
01139 qx = (s->mb_x << 6);
01140 qy = (s->mb_y << 6);
01141 X = (s->mb_width << 6) - 4;
01142 Y = (s->mb_height << 6) - 4;
01143 if(qx + px < -60) px = -60 - qx;
01144 if(qy + py < -60) py = -60 - qy;
01145 if(qx + px > X) px = X - qx;
01146 if(qy + py > Y) py = Y - qy;
01147 }
01148 }
01149
01150 if(0 && !s->first_slice_line && s->mb_x) {
01151 if(is_intra[xy - wrap])
01152 sum = FFABS(px) + FFABS(py);
01153 else
01154 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
01155 if(sum > 32) {
01156 if(get_bits1(&s->gb)) {
01157 px = A[0];
01158 py = A[1];
01159 } else {
01160 px = C[0];
01161 py = C[1];
01162 }
01163 } else {
01164 if(is_intra[xy - 2])
01165 sum = FFABS(px) + FFABS(py);
01166 else
01167 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
01168 if(sum > 32) {
01169 if(get_bits1(&s->gb)) {
01170 px = A[0];
01171 py = A[1];
01172 } else {
01173 px = C[0];
01174 py = C[1];
01175 }
01176 }
01177 }
01178 }
01179
01180
01181 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
01182 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
01183 }
01184 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
01185 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
01186 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
01187 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
01188 }
01189
01199 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
01200 int16_t **dc_val_ptr, int *dir_ptr)
01201 {
01202 int a, b, c, wrap, pred, scale;
01203 int16_t *dc_val;
01204 static const uint16_t dcpred[32] = {
01205 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
01206 114, 102, 93, 85, 79, 73, 68, 64,
01207 60, 57, 54, 51, 49, 47, 45, 43,
01208 41, 39, 38, 37, 35, 34, 33
01209 };
01210
01211
01212 if (n < 4) scale = s->y_dc_scale;
01213 else scale = s->c_dc_scale;
01214
01215 wrap = s->block_wrap[n];
01216 dc_val= s->dc_val[0] + s->block_index[n];
01217
01218
01219
01220
01221 c = dc_val[ - 1];
01222 b = dc_val[ - 1 - wrap];
01223 a = dc_val[ - wrap];
01224
01225 if (pq < 9 || !overlap)
01226 {
01227
01228 if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
01229 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
01230 }
01231 else
01232 {
01233
01234 if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
01235 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
01236 }
01237
01238 if (abs(a - b) <= abs(b - c)) {
01239 pred = c;
01240 *dir_ptr = 1;
01241 } else {
01242 pred = a;
01243 *dir_ptr = 0;
01244 }
01245
01246
01247 *dc_val_ptr = &dc_val[0];
01248 return pred;
01249 }
01250
01251
01263 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
01264 int a_avail, int c_avail,
01265 int16_t **dc_val_ptr, int *dir_ptr)
01266 {
01267 int a, b, c, wrap, pred;
01268 int16_t *dc_val;
01269 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01270 int q1, q2 = 0;
01271
01272 wrap = s->block_wrap[n];
01273 dc_val= s->dc_val[0] + s->block_index[n];
01274
01275
01276
01277
01278 c = dc_val[ - 1];
01279 b = dc_val[ - 1 - wrap];
01280 a = dc_val[ - wrap];
01281
01282 q1 = s->current_picture.qscale_table[mb_pos];
01283 if(c_avail && (n!= 1 && n!=3)) {
01284 q2 = s->current_picture.qscale_table[mb_pos - 1];
01285 if(q2 && q2 != q1)
01286 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
01287 }
01288 if(a_avail && (n!= 2 && n!=3)) {
01289 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
01290 if(q2 && q2 != q1)
01291 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
01292 }
01293 if(a_avail && c_avail && (n!=3)) {
01294 int off = mb_pos;
01295 if(n != 1) off--;
01296 if(n != 2) off -= s->mb_stride;
01297 q2 = s->current_picture.qscale_table[off];
01298 if(q2 && q2 != q1)
01299 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
01300 }
01301
01302 if(a_avail && c_avail) {
01303 if(abs(a - b) <= abs(b - c)) {
01304 pred = c;
01305 *dir_ptr = 1;
01306 } else {
01307 pred = a;
01308 *dir_ptr = 0;
01309 }
01310 } else if(a_avail) {
01311 pred = a;
01312 *dir_ptr = 0;
01313 } else if(c_avail) {
01314 pred = c;
01315 *dir_ptr = 1;
01316 } else {
01317 pred = 0;
01318 *dir_ptr = 1;
01319 }
01320
01321
01322 *dc_val_ptr = &dc_val[0];
01323 return pred;
01324 }
01325
01327
01334 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
01335 {
01336 int xy, wrap, pred, a, b, c;
01337
01338 xy = s->block_index[n];
01339 wrap = s->b8_stride;
01340
01341
01342
01343
01344 a = s->coded_block[xy - 1 ];
01345 b = s->coded_block[xy - 1 - wrap];
01346 c = s->coded_block[xy - wrap];
01347
01348 if (b == c) {
01349 pred = a;
01350 } else {
01351 pred = c;
01352 }
01353
01354
01355 *coded_block_ptr = &s->coded_block[xy];
01356
01357 return pred;
01358 }
01359
01369 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
01370 {
01371 GetBitContext *gb = &v->s.gb;
01372 int index, escape, run = 0, level = 0, lst = 0;
01373
01374 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
01375 if (index != vc1_ac_sizes[codingset] - 1) {
01376 run = vc1_index_decode_table[codingset][index][0];
01377 level = vc1_index_decode_table[codingset][index][1];
01378 lst = index >= vc1_last_decode_table[codingset];
01379 if(get_bits1(gb))
01380 level = -level;
01381 } else {
01382 escape = decode210(gb);
01383 if (escape != 2) {
01384 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
01385 run = vc1_index_decode_table[codingset][index][0];
01386 level = vc1_index_decode_table[codingset][index][1];
01387 lst = index >= vc1_last_decode_table[codingset];
01388 if(escape == 0) {
01389 if(lst)
01390 level += vc1_last_delta_level_table[codingset][run];
01391 else
01392 level += vc1_delta_level_table[codingset][run];
01393 } else {
01394 if(lst)
01395 run += vc1_last_delta_run_table[codingset][level] + 1;
01396 else
01397 run += vc1_delta_run_table[codingset][level] + 1;
01398 }
01399 if(get_bits1(gb))
01400 level = -level;
01401 } else {
01402 int sign;
01403 lst = get_bits1(gb);
01404 if(v->s.esc3_level_length == 0) {
01405 if(v->pq < 8 || v->dquantfrm) {
01406 v->s.esc3_level_length = get_bits(gb, 3);
01407 if(!v->s.esc3_level_length)
01408 v->s.esc3_level_length = get_bits(gb, 2) + 8;
01409 } else {
01410 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
01411 }
01412 v->s.esc3_run_length = 3 + get_bits(gb, 2);
01413 }
01414 run = get_bits(gb, v->s.esc3_run_length);
01415 sign = get_bits1(gb);
01416 level = get_bits(gb, v->s.esc3_level_length);
01417 if(sign)
01418 level = -level;
01419 }
01420 }
01421
01422 *last = lst;
01423 *skip = run;
01424 *value = level;
01425 }
01426
01434 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
01435 {
01436 GetBitContext *gb = &v->s.gb;
01437 MpegEncContext *s = &v->s;
01438 int dc_pred_dir = 0;
01439 int i;
01440 int16_t *dc_val;
01441 int16_t *ac_val, *ac_val2;
01442 int dcdiff;
01443
01444
01445 if (n < 4) {
01446 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01447 } else {
01448 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01449 }
01450 if (dcdiff < 0){
01451 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
01452 return -1;
01453 }
01454 if (dcdiff)
01455 {
01456 if (dcdiff == 119 )
01457 {
01458
01459 if (v->pq == 1) dcdiff = get_bits(gb, 10);
01460 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
01461 else dcdiff = get_bits(gb, 8);
01462 }
01463 else
01464 {
01465 if (v->pq == 1)
01466 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
01467 else if (v->pq == 2)
01468 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
01469 }
01470 if (get_bits1(gb))
01471 dcdiff = -dcdiff;
01472 }
01473
01474
01475 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
01476 *dc_val = dcdiff;
01477
01478
01479 if (n < 4) {
01480 block[0] = dcdiff * s->y_dc_scale;
01481 } else {
01482 block[0] = dcdiff * s->c_dc_scale;
01483 }
01484
01485 if (!coded) {
01486 goto not_coded;
01487 }
01488
01489
01490 i = 1;
01491
01492 {
01493 int last = 0, skip, value;
01494 const uint8_t *zz_table;
01495 int scale;
01496 int k;
01497
01498 scale = v->pq * 2 + v->halfpq;
01499
01500 if(v->s.ac_pred) {
01501 if(!dc_pred_dir)
01502 zz_table = wmv1_scantable[2];
01503 else
01504 zz_table = wmv1_scantable[3];
01505 } else
01506 zz_table = wmv1_scantable[1];
01507
01508 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01509 ac_val2 = ac_val;
01510 if(dc_pred_dir)
01511 ac_val -= 16;
01512 else
01513 ac_val -= 16 * s->block_wrap[n];
01514
01515 while (!last) {
01516 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
01517 i += skip;
01518 if(i > 63)
01519 break;
01520 block[zz_table[i++]] = value;
01521 }
01522
01523
01524 if(s->ac_pred) {
01525 if(dc_pred_dir) {
01526 for(k = 1; k < 8; k++)
01527 block[k << 3] += ac_val[k];
01528 } else {
01529 for(k = 1; k < 8; k++)
01530 block[k] += ac_val[k + 8];
01531 }
01532 }
01533
01534 for(k = 1; k < 8; k++) {
01535 ac_val2[k] = block[k << 3];
01536 ac_val2[k + 8] = block[k];
01537 }
01538
01539
01540 for(k = 1; k < 64; k++)
01541 if(block[k]) {
01542 block[k] *= scale;
01543 if(!v->pquantizer)
01544 block[k] += (block[k] < 0) ? -v->pq : v->pq;
01545 }
01546
01547 if(s->ac_pred) i = 63;
01548 }
01549
01550 not_coded:
01551 if(!coded) {
01552 int k, scale;
01553 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01554 ac_val2 = ac_val;
01555
01556 i = 0;
01557 scale = v->pq * 2 + v->halfpq;
01558 memset(ac_val2, 0, 16 * 2);
01559 if(dc_pred_dir) {
01560 ac_val -= 16;
01561 if(s->ac_pred)
01562 memcpy(ac_val2, ac_val, 8 * 2);
01563 } else {
01564 ac_val -= 16 * s->block_wrap[n];
01565 if(s->ac_pred)
01566 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
01567 }
01568
01569
01570 if(s->ac_pred) {
01571 if(dc_pred_dir) {
01572 for(k = 1; k < 8; k++) {
01573 block[k << 3] = ac_val[k] * scale;
01574 if(!v->pquantizer && block[k << 3])
01575 block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
01576 }
01577 } else {
01578 for(k = 1; k < 8; k++) {
01579 block[k] = ac_val[k + 8] * scale;
01580 if(!v->pquantizer && block[k])
01581 block[k] += (block[k] < 0) ? -v->pq : v->pq;
01582 }
01583 }
01584 i = 63;
01585 }
01586 }
01587 s->block_last_index[n] = i;
01588
01589 return 0;
01590 }
01591
01600 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
01601 {
01602 GetBitContext *gb = &v->s.gb;
01603 MpegEncContext *s = &v->s;
01604 int dc_pred_dir = 0;
01605 int i;
01606 int16_t *dc_val;
01607 int16_t *ac_val, *ac_val2;
01608 int dcdiff;
01609 int a_avail = v->a_avail, c_avail = v->c_avail;
01610 int use_pred = s->ac_pred;
01611 int scale;
01612 int q1, q2 = 0;
01613 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01614
01615
01616 if (n < 4) {
01617 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01618 } else {
01619 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01620 }
01621 if (dcdiff < 0){
01622 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
01623 return -1;
01624 }
01625 if (dcdiff)
01626 {
01627 if (dcdiff == 119 )
01628 {
01629
01630 if (mquant == 1) dcdiff = get_bits(gb, 10);
01631 else if (mquant == 2) dcdiff = get_bits(gb, 9);
01632 else dcdiff = get_bits(gb, 8);
01633 }
01634 else
01635 {
01636 if (mquant == 1)
01637 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
01638 else if (mquant == 2)
01639 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
01640 }
01641 if (get_bits1(gb))
01642 dcdiff = -dcdiff;
01643 }
01644
01645
01646 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
01647 *dc_val = dcdiff;
01648
01649
01650 if (n < 4) {
01651 block[0] = dcdiff * s->y_dc_scale;
01652 } else {
01653 block[0] = dcdiff * s->c_dc_scale;
01654 }
01655
01656
01657 i = 1;
01658
01659
01660 if(!a_avail && !c_avail) use_pred = 0;
01661 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01662 ac_val2 = ac_val;
01663
01664 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
01665
01666 if(dc_pred_dir)
01667 ac_val -= 16;
01668 else
01669 ac_val -= 16 * s->block_wrap[n];
01670
01671 q1 = s->current_picture.qscale_table[mb_pos];
01672 if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
01673 if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
01674 if(dc_pred_dir && n==1) q2 = q1;
01675 if(!dc_pred_dir && n==2) q2 = q1;
01676 if(n==3) q2 = q1;
01677
01678 if(coded) {
01679 int last = 0, skip, value;
01680 const uint8_t *zz_table;
01681 int k;
01682
01683 if(v->s.ac_pred) {
01684 if(!dc_pred_dir)
01685 zz_table = wmv1_scantable[2];
01686 else
01687 zz_table = wmv1_scantable[3];
01688 } else
01689 zz_table = wmv1_scantable[1];
01690
01691 while (!last) {
01692 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
01693 i += skip;
01694 if(i > 63)
01695 break;
01696 block[zz_table[i++]] = value;
01697 }
01698
01699
01700 if(use_pred) {
01701
01702 if(q2 && q1!=q2) {
01703 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01704 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01705
01706 if(dc_pred_dir) {
01707 for(k = 1; k < 8; k++)
01708 block[k << 3] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01709 } else {
01710 for(k = 1; k < 8; k++)
01711 block[k] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01712 }
01713 } else {
01714 if(dc_pred_dir) {
01715 for(k = 1; k < 8; k++)
01716 block[k << 3] += ac_val[k];
01717 } else {
01718 for(k = 1; k < 8; k++)
01719 block[k] += ac_val[k + 8];
01720 }
01721 }
01722 }
01723
01724 for(k = 1; k < 8; k++) {
01725 ac_val2[k] = block[k << 3];
01726 ac_val2[k + 8] = block[k];
01727 }
01728
01729
01730 for(k = 1; k < 64; k++)
01731 if(block[k]) {
01732 block[k] *= scale;
01733 if(!v->pquantizer)
01734 block[k] += (block[k] < 0) ? -mquant : mquant;
01735 }
01736
01737 if(use_pred) i = 63;
01738 } else {
01739 int k;
01740
01741 memset(ac_val2, 0, 16 * 2);
01742 if(dc_pred_dir) {
01743 if(use_pred) {
01744 memcpy(ac_val2, ac_val, 8 * 2);
01745 if(q2 && q1!=q2) {
01746 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01747 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01748 for(k = 1; k < 8; k++)
01749 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01750 }
01751 }
01752 } else {
01753 if(use_pred) {
01754 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
01755 if(q2 && q1!=q2) {
01756 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01757 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01758 for(k = 1; k < 8; k++)
01759 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01760 }
01761 }
01762 }
01763
01764
01765 if(use_pred) {
01766 if(dc_pred_dir) {
01767 for(k = 1; k < 8; k++) {
01768 block[k << 3] = ac_val2[k] * scale;
01769 if(!v->pquantizer && block[k << 3])
01770 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
01771 }
01772 } else {
01773 for(k = 1; k < 8; k++) {
01774 block[k] = ac_val2[k + 8] * scale;
01775 if(!v->pquantizer && block[k])
01776 block[k] += (block[k] < 0) ? -mquant : mquant;
01777 }
01778 }
01779 i = 63;
01780 }
01781 }
01782 s->block_last_index[n] = i;
01783
01784 return 0;
01785 }
01786
01795 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
01796 {
01797 GetBitContext *gb = &v->s.gb;
01798 MpegEncContext *s = &v->s;
01799 int dc_pred_dir = 0;
01800 int i;
01801 int16_t *dc_val;
01802 int16_t *ac_val, *ac_val2;
01803 int dcdiff;
01804 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01805 int a_avail = v->a_avail, c_avail = v->c_avail;
01806 int use_pred = s->ac_pred;
01807 int scale;
01808 int q1, q2 = 0;
01809
01810 s->dsp.clear_block(block);
01811
01812
01813 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
01814
01815
01816 s->y_dc_scale = s->y_dc_scale_table[mquant];
01817 s->c_dc_scale = s->c_dc_scale_table[mquant];
01818
01819
01820 if (n < 4) {
01821 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01822 } else {
01823 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01824 }
01825 if (dcdiff < 0){
01826 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
01827 return -1;
01828 }
01829 if (dcdiff)
01830 {
01831 if (dcdiff == 119 )
01832 {
01833
01834 if (mquant == 1) dcdiff = get_bits(gb, 10);
01835 else if (mquant == 2) dcdiff = get_bits(gb, 9);
01836 else dcdiff = get_bits(gb, 8);
01837 }
01838 else
01839 {
01840 if (mquant == 1)
01841 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
01842 else if (mquant == 2)
01843 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
01844 }
01845 if (get_bits1(gb))
01846 dcdiff = -dcdiff;
01847 }
01848
01849
01850 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
01851 *dc_val = dcdiff;
01852
01853
01854
01855 if (n < 4) {
01856 block[0] = dcdiff * s->y_dc_scale;
01857 } else {
01858 block[0] = dcdiff * s->c_dc_scale;
01859 }
01860
01861
01862 i = 1;
01863
01864
01865 if(!a_avail) dc_pred_dir = 1;
01866 if(!c_avail) dc_pred_dir = 0;
01867 if(!a_avail && !c_avail) use_pred = 0;
01868 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01869 ac_val2 = ac_val;
01870
01871 scale = mquant * 2 + v->halfpq;
01872
01873 if(dc_pred_dir)
01874 ac_val -= 16;
01875 else
01876 ac_val -= 16 * s->block_wrap[n];
01877
01878 q1 = s->current_picture.qscale_table[mb_pos];
01879 if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
01880 if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
01881 if(dc_pred_dir && n==1) q2 = q1;
01882 if(!dc_pred_dir && n==2) q2 = q1;
01883 if(n==3) q2 = q1;
01884
01885 if(coded) {
01886 int last = 0, skip, value;
01887 const uint8_t *zz_table;
01888 int k;
01889
01890 zz_table = wmv1_scantable[0];
01891
01892 while (!last) {
01893 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
01894 i += skip;
01895 if(i > 63)
01896 break;
01897 block[zz_table[i++]] = value;
01898 }
01899
01900
01901 if(use_pred) {
01902
01903 if(q2 && q1!=q2) {
01904 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01905 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01906
01907 if(dc_pred_dir) {
01908 for(k = 1; k < 8; k++)
01909 block[k << 3] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01910 } else {
01911 for(k = 1; k < 8; k++)
01912 block[k] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01913 }
01914 } else {
01915 if(dc_pred_dir) {
01916 for(k = 1; k < 8; k++)
01917 block[k << 3] += ac_val[k];
01918 } else {
01919 for(k = 1; k < 8; k++)
01920 block[k] += ac_val[k + 8];
01921 }
01922 }
01923 }
01924
01925 for(k = 1; k < 8; k++) {
01926 ac_val2[k] = block[k << 3];
01927 ac_val2[k + 8] = block[k];
01928 }
01929
01930
01931 for(k = 1; k < 64; k++)
01932 if(block[k]) {
01933 block[k] *= scale;
01934 if(!v->pquantizer)
01935 block[k] += (block[k] < 0) ? -mquant : mquant;
01936 }
01937
01938 if(use_pred) i = 63;
01939 } else {
01940 int k;
01941
01942 memset(ac_val2, 0, 16 * 2);
01943 if(dc_pred_dir) {
01944 if(use_pred) {
01945 memcpy(ac_val2, ac_val, 8 * 2);
01946 if(q2 && q1!=q2) {
01947 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01948 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01949 for(k = 1; k < 8; k++)
01950 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01951 }
01952 }
01953 } else {
01954 if(use_pred) {
01955 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
01956 if(q2 && q1!=q2) {
01957 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01958 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01959 for(k = 1; k < 8; k++)
01960 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01961 }
01962 }
01963 }
01964
01965
01966 if(use_pred) {
01967 if(dc_pred_dir) {
01968 for(k = 1; k < 8; k++) {
01969 block[k << 3] = ac_val2[k] * scale;
01970 if(!v->pquantizer && block[k << 3])
01971 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
01972 }
01973 } else {
01974 for(k = 1; k < 8; k++) {
01975 block[k] = ac_val2[k + 8] * scale;
01976 if(!v->pquantizer && block[k])
01977 block[k] += (block[k] < 0) ? -mquant : mquant;
01978 }
01979 }
01980 i = 63;
01981 }
01982 }
01983 s->block_last_index[n] = i;
01984
01985 return 0;
01986 }
01987
01990 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block,
01991 uint8_t *dst, int linesize, int skip_block, int apply_filter, int cbp_top, int cbp_left)
01992 {
01993 MpegEncContext *s = &v->s;
01994 GetBitContext *gb = &s->gb;
01995 int i, j;
01996 int subblkpat = 0;
01997 int scale, off, idx, last, skip, value;
01998 int ttblk = ttmb & 7;
01999 int pat = 0;
02000
02001 s->dsp.clear_block(block);
02002
02003 if(ttmb == -1) {
02004 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)];
02005 }
02006 if(ttblk == TT_4X4) {
02007 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
02008 }
02009 if((ttblk != TT_8X8 && ttblk != TT_4X4)
02010 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
02011 || (!v->res_rtm_flag && !first_block))) {
02012 subblkpat = decode012(gb);
02013 if(subblkpat) subblkpat ^= 3;
02014 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
02015 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
02016 }
02017 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
02018
02019
02020 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
02021 subblkpat = 2 - (ttblk == TT_8X4_TOP);
02022 ttblk = TT_8X4;
02023 }
02024 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
02025 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
02026 ttblk = TT_4X8;
02027 }
02028 switch(ttblk) {
02029 case TT_8X8:
02030 pat = 0xF;
02031 i = 0;
02032 last = 0;
02033 while (!last) {
02034 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02035 i += skip;
02036 if(i > 63)
02037 break;
02038 idx = wmv1_scantable[0][i++];
02039 block[idx] = value * scale;
02040 if(!v->pquantizer)
02041 block[idx] += (block[idx] < 0) ? -mquant : mquant;
02042 }
02043 if(!skip_block){
02044 if(i==1)
02045 s->dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
02046 else{
02047 s->dsp.vc1_inv_trans_8x8(block);
02048 s->dsp.add_pixels_clamped(block, dst, linesize);
02049 }
02050 if(apply_filter && cbp_top & 0xC)
02051 s->dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
02052 if(apply_filter && cbp_left & 0xA)
02053 s->dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
02054 }
02055 break;
02056 case TT_4X4:
02057 pat = ~subblkpat & 0xF;
02058 for(j = 0; j < 4; j++) {
02059 last = subblkpat & (1 << (3 - j));
02060 i = 0;
02061 off = (j & 1) * 4 + (j & 2) * 16;
02062 while (!last) {
02063 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02064 i += skip;
02065 if(i > 15)
02066 break;
02067 idx = ff_vc1_simple_progressive_4x4_zz[i++];
02068 block[idx + off] = value * scale;
02069 if(!v->pquantizer)
02070 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
02071 }
02072 if(!(subblkpat & (1 << (3 - j))) && !skip_block){
02073 if(i==1)
02074 s->dsp.vc1_inv_trans_4x4_dc(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off);
02075 else
02076 s->dsp.vc1_inv_trans_4x4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off);
02077 if(apply_filter && (j&2 ? pat & (1<<(j-2)) : (cbp_top & (1 << (j + 2)))))
02078 s->dsp.vc1_v_loop_filter4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, v->pq);
02079 if(apply_filter && (j&1 ? pat & (1<<(j-1)) : (cbp_left & (1 << (j + 1)))))
02080 s->dsp.vc1_h_loop_filter4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, v->pq);
02081 }
02082 }
02083 break;
02084 case TT_8X4:
02085 pat = ~((subblkpat & 2)*6 + (subblkpat & 1)*3) & 0xF;
02086 for(j = 0; j < 2; j++) {
02087 last = subblkpat & (1 << (1 - j));
02088 i = 0;
02089 off = j * 32;
02090 while (!last) {
02091 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02092 i += skip;
02093 if(i > 31)
02094 break;
02095 idx = v->zz_8x4[i++]+off;
02096 block[idx] = value * scale;
02097 if(!v->pquantizer)
02098 block[idx] += (block[idx] < 0) ? -mquant : mquant;
02099 }
02100 if(!(subblkpat & (1 << (1 - j))) && !skip_block){
02101 if(i==1)
02102 s->dsp.vc1_inv_trans_8x4_dc(dst + j*4*linesize, linesize, block + off);
02103 else
02104 s->dsp.vc1_inv_trans_8x4(dst + j*4*linesize, linesize, block + off);
02105 if(apply_filter && j ? pat & 0x3 : (cbp_top & 0xC))
02106 s->dsp.vc1_v_loop_filter8(dst + j*4*linesize, linesize, v->pq);
02107 if(apply_filter && cbp_left & (2 << j))
02108 s->dsp.vc1_h_loop_filter4(dst + j*4*linesize, linesize, v->pq);
02109 }
02110 }
02111 break;
02112 case TT_4X8:
02113 pat = ~(subblkpat*5) & 0xF;
02114 for(j = 0; j < 2; j++) {
02115 last = subblkpat & (1 << (1 - j));
02116 i = 0;
02117 off = j * 4;
02118 while (!last) {
02119 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02120 i += skip;
02121 if(i > 31)
02122 break;
02123 idx = v->zz_4x8[i++]+off;
02124 block[idx] = value * scale;
02125 if(!v->pquantizer)
02126 block[idx] += (block[idx] < 0) ? -mquant : mquant;
02127 }
02128 if(!(subblkpat & (1 << (1 - j))) && !skip_block){
02129 if(i==1)
02130 s->dsp.vc1_inv_trans_4x8_dc(dst + j*4, linesize, block + off);
02131 else
02132 s->dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
02133 if(apply_filter && cbp_top & (2 << j))
02134 s->dsp.vc1_v_loop_filter4(dst + j*4, linesize, v->pq);
02135 if(apply_filter && j ? pat & 0x5 : (cbp_left & 0xA))
02136 s->dsp.vc1_h_loop_filter8(dst + j*4, linesize, v->pq);
02137 }
02138 }
02139 break;
02140 }
02141 return pat;
02142 }
02143
02145
02146 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
02147 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
02148
02151 static int vc1_decode_p_mb(VC1Context *v)
02152 {
02153 MpegEncContext *s = &v->s;
02154 GetBitContext *gb = &s->gb;
02155 int i, j;
02156 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02157 int cbp;
02158 int mqdiff, mquant;
02159 int ttmb = v->ttfrm;
02160
02161 int mb_has_coeffs = 1;
02162 int dmv_x, dmv_y;
02163 int index, index1;
02164 int val, sign;
02165 int first_block = 1;
02166 int dst_idx, off;
02167 int skipped, fourmv;
02168 int block_cbp = 0, pat;
02169 int apply_loop_filter;
02170
02171 mquant = v->pq;
02172
02173 if (v->mv_type_is_raw)
02174 fourmv = get_bits1(gb);
02175 else
02176 fourmv = v->mv_type_mb_plane[mb_pos];
02177 if (v->skip_is_raw)
02178 skipped = get_bits1(gb);
02179 else
02180 skipped = v->s.mbskip_table[mb_pos];
02181
02182 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
02183 if (!fourmv)
02184 {
02185 if (!skipped)
02186 {
02187 GET_MVDATA(dmv_x, dmv_y);
02188
02189 if (s->mb_intra) {
02190 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
02191 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
02192 }
02193 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
02194 vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
02195
02196
02197 if (s->mb_intra && !mb_has_coeffs)
02198 {
02199 GET_MQUANT();
02200 s->ac_pred = get_bits1(gb);
02201 cbp = 0;
02202 }
02203 else if (mb_has_coeffs)
02204 {
02205 if (s->mb_intra) s->ac_pred = get_bits1(gb);
02206 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02207 GET_MQUANT();
02208 }
02209 else
02210 {
02211 mquant = v->pq;
02212 cbp = 0;
02213 }
02214 s->current_picture.qscale_table[mb_pos] = mquant;
02215
02216 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
02217 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
02218 VC1_TTMB_VLC_BITS, 2);
02219 if(!s->mb_intra) vc1_mc_1mv(v, 0);
02220 dst_idx = 0;
02221 for (i=0; i<6; i++)
02222 {
02223 s->dc_val[0][s->block_index[i]] = 0;
02224 dst_idx += i >> 2;
02225 val = ((cbp >> (5 - i)) & 1);
02226 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
02227 v->mb_type[0][s->block_index[i]] = s->mb_intra;
02228 if(s->mb_intra) {
02229
02230 v->a_avail = v->c_avail = 0;
02231 if(i == 2 || i == 3 || !s->first_slice_line)
02232 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
02233 if(i == 1 || i == 3 || s->mb_x)
02234 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
02235
02236 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
02237 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
02238 s->dsp.vc1_inv_trans_8x8(s->block[i]);
02239 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
02240 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02241 if(v->pq >= 9 && v->overlap) {
02242 if(v->c_avail)
02243 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02244 if(v->a_avail)
02245 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02246 }
02247 if(apply_loop_filter && s->mb_x && s->mb_x != (s->mb_width - 1) && s->mb_y && s->mb_y != (s->mb_height - 1)){
02248 int left_cbp, top_cbp;
02249 if(i & 4){
02250 left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
02251 top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
02252 }else{
02253 left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
02254 top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
02255 }
02256 if(left_cbp & 0xC)
02257 s->dsp.vc1_v_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02258 if(top_cbp & 0xA)
02259 s->dsp.vc1_h_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02260 }
02261 block_cbp |= 0xF << (i << 2);
02262 } else if(val) {
02263 int left_cbp = 0, top_cbp = 0, filter = 0;
02264 if(apply_loop_filter && s->mb_x && s->mb_x != (s->mb_width - 1) && s->mb_y && s->mb_y != (s->mb_height - 1)){
02265 filter = 1;
02266 if(i & 4){
02267 left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
02268 top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
02269 }else{
02270 left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
02271 top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
02272 }
02273 if(left_cbp & 0xC)
02274 s->dsp.vc1_v_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02275 if(top_cbp & 0xA)
02276 s->dsp.vc1_h_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02277 }
02278 pat = 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), filter, left_cbp, top_cbp);
02279 block_cbp |= pat << (i << 2);
02280 if(!v->ttmbf && ttmb < 8) ttmb = -1;
02281 first_block = 0;
02282 }
02283 }
02284 }
02285 else
02286 {
02287 s->mb_intra = 0;
02288 for(i = 0; i < 6; i++) {
02289 v->mb_type[0][s->block_index[i]] = 0;
02290 s->dc_val[0][s->block_index[i]] = 0;
02291 }
02292 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
02293 s->current_picture.qscale_table[mb_pos] = 0;
02294 vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
02295 vc1_mc_1mv(v, 0);
02296 return 0;
02297 }
02298 }
02299 else
02300 {
02301 if (!skipped )
02302 {
02303 int intra_count = 0, coded_inter = 0;
02304 int is_intra[6], is_coded[6];
02305
02306 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02307 for (i=0; i<6; i++)
02308 {
02309 val = ((cbp >> (5 - i)) & 1);
02310 s->dc_val[0][s->block_index[i]] = 0;
02311 s->mb_intra = 0;
02312 if(i < 4) {
02313 dmv_x = dmv_y = 0;
02314 s->mb_intra = 0;
02315 mb_has_coeffs = 0;
02316 if(val) {
02317 GET_MVDATA(dmv_x, dmv_y);
02318 }
02319 vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
02320 if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
02321 intra_count += s->mb_intra;
02322 is_intra[i] = s->mb_intra;
02323 is_coded[i] = mb_has_coeffs;
02324 }
02325 if(i&4){
02326 is_intra[i] = (intra_count >= 3);
02327 is_coded[i] = val;
02328 }
02329 if(i == 4) vc1_mc_4mv_chroma(v);
02330 v->mb_type[0][s->block_index[i]] = is_intra[i];
02331 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
02332 }
02333
02334 if(!intra_count && !coded_inter) return 0;
02335 dst_idx = 0;
02336 GET_MQUANT();
02337 s->current_picture.qscale_table[mb_pos] = mquant;
02338
02339 {
02340 int intrapred = 0;
02341 for(i=0; i<6; i++)
02342 if(is_intra[i]) {
02343 if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
02344 || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
02345 intrapred = 1;
02346 break;
02347 }
02348 }
02349 if(intrapred)s->ac_pred = get_bits1(gb);
02350 else s->ac_pred = 0;
02351 }
02352 if (!v->ttmbf && coded_inter)
02353 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
02354 for (i=0; i<6; i++)
02355 {
02356 dst_idx += i >> 2;
02357 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
02358 s->mb_intra = is_intra[i];
02359 if (is_intra[i]) {
02360
02361 v->a_avail = v->c_avail = 0;
02362 if(i == 2 || i == 3 || !s->first_slice_line)
02363 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
02364 if(i == 1 || i == 3 || s->mb_x)
02365 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
02366
02367 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
02368 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
02369 s->dsp.vc1_inv_trans_8x8(s->block[i]);
02370 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
02371 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
02372 if(v->pq >= 9 && v->overlap) {
02373 if(v->c_avail)
02374 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02375 if(v->a_avail)
02376 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02377 }
02378 if(v->s.loop_filter && s->mb_x && s->mb_x != (s->mb_width - 1) && s->mb_y && s->mb_y != (s->mb_height - 1)){
02379 int left_cbp, top_cbp;
02380 if(i & 4){
02381 left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
02382 top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
02383 }else{
02384 left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
02385 top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
02386 }
02387 if(left_cbp & 0xC)
02388 s->dsp.vc1_v_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02389 if(top_cbp & 0xA)
02390 s->dsp.vc1_h_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02391 }
02392 block_cbp |= 0xF << (i << 2);
02393 } else if(is_coded[i]) {
02394 int left_cbp = 0, top_cbp = 0, filter = 0;
02395 if(v->s.loop_filter && s->mb_x && s->mb_x != (s->mb_width - 1) && s->mb_y && s->mb_y != (s->mb_height - 1)){
02396 filter = 1;
02397 if(i & 4){
02398 left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
02399 top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
02400 }else{
02401 left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
02402 top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
02403 }
02404 if(left_cbp & 0xC)
02405 s->dsp.vc1_v_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02406 if(top_cbp & 0xA)
02407 s->dsp.vc1_h_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02408 }
02409 pat = 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), filter, left_cbp, top_cbp);
02410 block_cbp |= pat << (i << 2);
02411 if(!v->ttmbf && ttmb < 8) ttmb = -1;
02412 first_block = 0;
02413 }
02414 }
02415 return 0;
02416 }
02417 else
02418 {
02419 s->mb_intra = 0;
02420 s->current_picture.qscale_table[mb_pos] = 0;
02421 for (i=0; i<6; i++) {
02422 v->mb_type[0][s->block_index[i]] = 0;
02423 s->dc_val[0][s->block_index[i]] = 0;
02424 }
02425 for (i=0; i<4; i++)
02426 {
02427 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
02428 vc1_mc_4mv_luma(v, i);
02429 }
02430 vc1_mc_4mv_chroma(v);
02431 s->current_picture.qscale_table[mb_pos] = 0;
02432 return 0;
02433 }
02434 }
02435 v->cbp[s->mb_x] = block_cbp;
02436
02437
02438 return -1;
02439 }
02440
02443 static void vc1_decode_b_mb(VC1Context *v)
02444 {
02445 MpegEncContext *s = &v->s;
02446 GetBitContext *gb = &s->gb;
02447 int i, j;
02448 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02449 int cbp = 0;
02450 int mqdiff, mquant;
02451 int ttmb = v->ttfrm;
02452 int mb_has_coeffs = 0;
02453 int index, index1;
02454 int val, sign;
02455 int first_block = 1;
02456 int dst_idx, off;
02457 int skipped, direct;
02458 int dmv_x[2], dmv_y[2];
02459 int bmvtype = BMV_TYPE_BACKWARD;
02460
02461 mquant = v->pq;
02462 s->mb_intra = 0;
02463
02464 if (v->dmb_is_raw)
02465 direct = get_bits1(gb);
02466 else
02467 direct = v->direct_mb_plane[mb_pos];
02468 if (v->skip_is_raw)
02469 skipped = get_bits1(gb);
02470 else
02471 skipped = v->s.mbskip_table[mb_pos];
02472
02473 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
02474 for(i = 0; i < 6; i++) {
02475 v->mb_type[0][s->block_index[i]] = 0;
02476 s->dc_val[0][s->block_index[i]] = 0;
02477 }
02478 s->current_picture.qscale_table[mb_pos] = 0;
02479
02480 if (!direct) {
02481 if (!skipped) {
02482 GET_MVDATA(dmv_x[0], dmv_y[0]);
02483 dmv_x[1] = dmv_x[0];
02484 dmv_y[1] = dmv_y[0];
02485 }
02486 if(skipped || !s->mb_intra) {
02487 bmvtype = decode012(gb);
02488 switch(bmvtype) {
02489 case 0:
02490 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
02491 break;
02492 case 1:
02493 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
02494 break;
02495 case 2:
02496 bmvtype = BMV_TYPE_INTERPOLATED;
02497 dmv_x[0] = dmv_y[0] = 0;
02498 }
02499 }
02500 }
02501 for(i = 0; i < 6; i++)
02502 v->mb_type[0][s->block_index[i]] = s->mb_intra;
02503
02504 if (skipped) {
02505 if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
02506 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02507 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02508 return;
02509 }
02510 if (direct) {
02511 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02512 GET_MQUANT();
02513 s->mb_intra = 0;
02514 s->current_picture.qscale_table[mb_pos] = mquant;
02515 if(!v->ttmbf)
02516 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
02517 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
02518 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02519 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02520 } else {
02521 if(!mb_has_coeffs && !s->mb_intra) {
02522
02523 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02524 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02525 return;
02526 }
02527 if(s->mb_intra && !mb_has_coeffs) {
02528 GET_MQUANT();
02529 s->current_picture.qscale_table[mb_pos] = mquant;
02530 s->ac_pred = get_bits1(gb);
02531 cbp = 0;
02532 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02533 } else {
02534 if(bmvtype == BMV_TYPE_INTERPOLATED) {
02535 GET_MVDATA(dmv_x[0], dmv_y[0]);
02536 if(!mb_has_coeffs) {
02537
02538 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02539 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02540 return;
02541 }
02542 }
02543 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02544 if(!s->mb_intra) {
02545 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02546 }
02547 if(s->mb_intra)
02548 s->ac_pred = get_bits1(gb);
02549 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02550 GET_MQUANT();
02551 s->current_picture.qscale_table[mb_pos] = mquant;
02552 if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
02553 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
02554 }
02555 }
02556 dst_idx = 0;
02557 for (i=0; i<6; i++)
02558 {
02559 s->dc_val[0][s->block_index[i]] = 0;
02560 dst_idx += i >> 2;
02561 val = ((cbp >> (5 - i)) & 1);
02562 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
02563 v->mb_type[0][s->block_index[i]] = s->mb_intra;
02564 if(s->mb_intra) {
02565
02566 v->a_avail = v->c_avail = 0;
02567 if(i == 2 || i == 3 || !s->first_slice_line)
02568 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
02569 if(i == 1 || i == 3 || s->mb_x)
02570 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
02571
02572 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
02573 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
02574 s->dsp.vc1_inv_trans_8x8(s->block[i]);
02575 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
02576 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02577 } else if(val) {
02578 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), 0, 0, 0);
02579 if(!v->ttmbf && ttmb < 8) ttmb = -1;
02580 first_block = 0;
02581 }
02582 }
02583 }
02584
02587 static void vc1_decode_i_blocks(VC1Context *v)
02588 {
02589 int k, j;
02590 MpegEncContext *s = &v->s;
02591 int cbp, val;
02592 uint8_t *coded_val;
02593 int mb_pos;
02594
02595
02596 switch(v->y_ac_table_index){
02597 case 0:
02598 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
02599 break;
02600 case 1:
02601 v->codingset = CS_HIGH_MOT_INTRA;
02602 break;
02603 case 2:
02604 v->codingset = CS_MID_RATE_INTRA;
02605 break;
02606 }
02607
02608 switch(v->c_ac_table_index){
02609 case 0:
02610 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
02611 break;
02612 case 1:
02613 v->codingset2 = CS_HIGH_MOT_INTER;
02614 break;
02615 case 2:
02616 v->codingset2 = CS_MID_RATE_INTER;
02617 break;
02618 }
02619
02620
02621 s->y_dc_scale = s->y_dc_scale_table[v->pq];
02622 s->c_dc_scale = s->c_dc_scale_table[v->pq];
02623
02624
02625 s->mb_x = s->mb_y = 0;
02626 s->mb_intra = 1;
02627 s->first_slice_line = 1;
02628 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02629 s->mb_x = 0;
02630 ff_init_block_index(s);
02631 for(; s->mb_x < s->mb_width; s->mb_x++) {
02632 ff_update_block_index(s);
02633 s->dsp.clear_blocks(s->block[0]);
02634 mb_pos = s->mb_x + s->mb_y * s->mb_width;
02635 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
02636 s->current_picture.qscale_table[mb_pos] = v->pq;
02637 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
02638 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
02639
02640
02641 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
02642 v->s.ac_pred = get_bits1(&v->s.gb);
02643
02644 for(k = 0; k < 6; k++) {
02645 val = ((cbp >> (5 - k)) & 1);
02646
02647 if (k < 4) {
02648 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
02649 val = val ^ pred;
02650 *coded_val = val;
02651 }
02652 cbp |= val << (5 - k);
02653
02654 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
02655
02656 s->dsp.vc1_inv_trans_8x8(s->block[k]);
02657 if(v->pq >= 9 && v->overlap) {
02658 for(j = 0; j < 64; j++) s->block[k][j] += 128;
02659 }
02660 }
02661
02662 vc1_put_block(v, s->block);
02663 if(v->pq >= 9 && v->overlap) {
02664 if(s->mb_x) {
02665 s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
02666 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
02667 if(!(s->flags & CODEC_FLAG_GRAY)) {
02668 s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
02669 s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
02670 }
02671 }
02672 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
02673 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
02674 if(!s->first_slice_line) {
02675 s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
02676 s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
02677 if(!(s->flags & CODEC_FLAG_GRAY)) {
02678 s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
02679 s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
02680 }
02681 }
02682 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
02683 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
02684 }
02685 if(v->s.loop_filter) vc1_loop_filter_iblk(s, v->pq);
02686
02687 if(get_bits_count(&s->gb) > v->bits) {
02688 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
02689 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
02690 return;
02691 }
02692 }
02693 if (!v->s.loop_filter)
02694 ff_draw_horiz_band(s, s->mb_y * 16, 16);
02695 else if (s->mb_y)
02696 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
02697
02698 s->first_slice_line = 0;
02699 }
02700 if (v->s.loop_filter)
02701 ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
02702 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02703 }
02704
02707 static void vc1_decode_i_blocks_adv(VC1Context *v)
02708 {
02709 int k, j;
02710 MpegEncContext *s = &v->s;
02711 int cbp, val;
02712 uint8_t *coded_val;
02713 int mb_pos;
02714 int mquant = v->pq;
02715 int mqdiff;
02716 int overlap;
02717 GetBitContext *gb = &s->gb;
02718
02719
02720 switch(v->y_ac_table_index){
02721 case 0:
02722 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
02723 break;
02724 case 1:
02725 v->codingset = CS_HIGH_MOT_INTRA;
02726 break;
02727 case 2:
02728 v->codingset = CS_MID_RATE_INTRA;
02729 break;
02730 }
02731
02732 switch(v->c_ac_table_index){
02733 case 0:
02734 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
02735 break;
02736 case 1:
02737 v->codingset2 = CS_HIGH_MOT_INTER;
02738 break;
02739 case 2:
02740 v->codingset2 = CS_MID_RATE_INTER;
02741 break;
02742 }
02743
02744
02745 s->mb_x = s->mb_y = 0;
02746 s->mb_intra = 1;
02747 s->first_slice_line = 1;
02748 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02749 s->mb_x = 0;
02750 ff_init_block_index(s);
02751 for(;s->mb_x < s->mb_width; s->mb_x++) {
02752 ff_update_block_index(s);
02753 s->dsp.clear_blocks(s->block[0]);
02754 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02755 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
02756 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
02757 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
02758
02759
02760 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
02761 if(v->acpred_is_raw)
02762 v->s.ac_pred = get_bits1(&v->s.gb);
02763 else
02764 v->s.ac_pred = v->acpred_plane[mb_pos];
02765
02766 if(v->condover == CONDOVER_SELECT) {
02767 if(v->overflg_is_raw)
02768 overlap = get_bits1(&v->s.gb);
02769 else
02770 overlap = v->over_flags_plane[mb_pos];
02771 } else
02772 overlap = (v->condover == CONDOVER_ALL);
02773
02774 GET_MQUANT();
02775
02776 s->current_picture.qscale_table[mb_pos] = mquant;
02777
02778 s->y_dc_scale = s->y_dc_scale_table[mquant];
02779 s->c_dc_scale = s->c_dc_scale_table[mquant];
02780
02781 for(k = 0; k < 6; k++) {
02782 val = ((cbp >> (5 - k)) & 1);
02783
02784 if (k < 4) {
02785 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
02786 val = val ^ pred;
02787 *coded_val = val;
02788 }
02789 cbp |= val << (5 - k);
02790
02791 v->a_avail = !s->first_slice_line || (k==2 || k==3);
02792 v->c_avail = !!s->mb_x || (k==1 || k==3);
02793
02794 vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
02795
02796 s->dsp.vc1_inv_trans_8x8(s->block[k]);
02797 for(j = 0; j < 64; j++) s->block[k][j] += 128;
02798 }
02799
02800 vc1_put_block(v, s->block);
02801 if(overlap) {
02802 if(s->mb_x) {
02803 s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
02804 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
02805 if(!(s->flags & CODEC_FLAG_GRAY)) {
02806 s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
02807 s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
02808 }
02809 }
02810 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
02811 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
02812 if(!s->first_slice_line) {
02813 s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
02814 s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
02815 if(!(s->flags & CODEC_FLAG_GRAY)) {
02816 s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
02817 s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
02818 }
02819 }
02820 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
02821 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
02822 }
02823 if(v->s.loop_filter) vc1_loop_filter_iblk(s, v->pq);
02824
02825 if(get_bits_count(&s->gb) > v->bits) {
02826 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
02827 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
02828 return;
02829 }
02830 }
02831 if (!v->s.loop_filter)
02832 ff_draw_horiz_band(s, s->mb_y * 16, 16);
02833 else if (s->mb_y)
02834 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
02835 s->first_slice_line = 0;
02836 }
02837 if (v->s.loop_filter)
02838 ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
02839 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02840 }
02841
02842 static void vc1_decode_p_blocks(VC1Context *v)
02843 {
02844 MpegEncContext *s = &v->s;
02845
02846
02847 switch(v->c_ac_table_index){
02848 case 0:
02849 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
02850 break;
02851 case 1:
02852 v->codingset = CS_HIGH_MOT_INTRA;
02853 break;
02854 case 2:
02855 v->codingset = CS_MID_RATE_INTRA;
02856 break;
02857 }
02858
02859 switch(v->c_ac_table_index){
02860 case 0:
02861 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
02862 break;
02863 case 1:
02864 v->codingset2 = CS_HIGH_MOT_INTER;
02865 break;
02866 case 2:
02867 v->codingset2 = CS_MID_RATE_INTER;
02868 break;
02869 }
02870
02871 s->first_slice_line = 1;
02872 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
02873 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02874 s->mb_x = 0;
02875 ff_init_block_index(s);
02876 for(; s->mb_x < s->mb_width; s->mb_x++) {
02877 ff_update_block_index(s);
02878
02879 vc1_decode_p_mb(v);
02880 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
02881 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
02882 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);
02883 return;
02884 }
02885 }
02886 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0])*s->mb_stride);
02887 ff_draw_horiz_band(s, s->mb_y * 16, 16);
02888 s->first_slice_line = 0;
02889 }
02890 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02891 }
02892
02893 static void vc1_decode_b_blocks(VC1Context *v)
02894 {
02895 MpegEncContext *s = &v->s;
02896
02897
02898 switch(v->c_ac_table_index){
02899 case 0:
02900 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
02901 break;
02902 case 1:
02903 v->codingset = CS_HIGH_MOT_INTRA;
02904 break;
02905 case 2:
02906 v->codingset = CS_MID_RATE_INTRA;
02907 break;
02908 }
02909
02910 switch(v->c_ac_table_index){
02911 case 0:
02912 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
02913 break;
02914 case 1:
02915 v->codingset2 = CS_HIGH_MOT_INTER;
02916 break;
02917 case 2:
02918 v->codingset2 = CS_MID_RATE_INTER;
02919 break;
02920 }
02921
02922 s->first_slice_line = 1;
02923 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02924 s->mb_x = 0;
02925 ff_init_block_index(s);
02926 for(; s->mb_x < s->mb_width; s->mb_x++) {
02927 ff_update_block_index(s);
02928
02929 vc1_decode_b_mb(v);
02930 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
02931 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
02932 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);
02933 return;
02934 }
02935 if(v->s.loop_filter) vc1_loop_filter_iblk(s, v->pq);
02936 }
02937 if (!v->s.loop_filter)
02938 ff_draw_horiz_band(s, s->mb_y * 16, 16);
02939 else if (s->mb_y)
02940 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
02941 s->first_slice_line = 0;
02942 }
02943 if (v->s.loop_filter)
02944 ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
02945 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02946 }
02947
02948 static void vc1_decode_skip_blocks(VC1Context *v)
02949 {
02950 MpegEncContext *s = &v->s;
02951
02952 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02953 s->first_slice_line = 1;
02954 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02955 s->mb_x = 0;
02956 ff_init_block_index(s);
02957 ff_update_block_index(s);
02958 memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
02959 memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
02960 memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
02961 ff_draw_horiz_band(s, s->mb_y * 16, 16);
02962 s->first_slice_line = 0;
02963 }
02964 s->pict_type = FF_P_TYPE;
02965 }
02966
02967 static void vc1_decode_blocks(VC1Context *v)
02968 {
02969
02970 v->s.esc3_level_length = 0;
02971 if(v->x8_type){
02972 ff_intrax8_decode_picture(&v->x8, 2*v->pq+v->halfpq, v->pq*(!v->pquantizer) );
02973 }else{
02974
02975 switch(v->s.pict_type) {
02976 case FF_I_TYPE:
02977 if(v->profile == PROFILE_ADVANCED)
02978 vc1_decode_i_blocks_adv(v);
02979 else
02980 vc1_decode_i_blocks(v);
02981 break;
02982 case FF_P_TYPE:
02983 if(v->p_frame_skipped)
02984 vc1_decode_skip_blocks(v);
02985 else
02986 vc1_decode_p_blocks(v);
02987 break;
02988 case FF_B_TYPE:
02989 if(v->bi_type){
02990 if(v->profile == PROFILE_ADVANCED)
02991 vc1_decode_i_blocks_adv(v);
02992 else
02993 vc1_decode_i_blocks(v);
02994 }else
02995 vc1_decode_b_blocks(v);
02996 break;
02997 }
02998 }
02999 }
03000
03005 static av_cold int vc1_decode_init(AVCodecContext *avctx)
03006 {
03007 VC1Context *v = avctx->priv_data;
03008 MpegEncContext *s = &v->s;
03009 GetBitContext gb;
03010
03011 if (!avctx->extradata_size || !avctx->extradata) return -1;
03012 if (!(avctx->flags & CODEC_FLAG_GRAY))
03013 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
03014 else
03015 avctx->pix_fmt = PIX_FMT_GRAY8;
03016 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
03017 v->s.avctx = avctx;
03018 avctx->flags |= CODEC_FLAG_EMU_EDGE;
03019 v->s.flags |= CODEC_FLAG_EMU_EDGE;
03020
03021 if(avctx->idct_algo==FF_IDCT_AUTO){
03022 avctx->idct_algo=FF_IDCT_WMV2;
03023 }
03024
03025 if(ff_msmpeg4_decode_init(avctx) < 0)
03026 return -1;
03027 if (vc1_init_common(v) < 0) return -1;
03028
03029 avctx->coded_width = avctx->width;
03030 avctx->coded_height = avctx->height;
03031 if (avctx->codec_id == CODEC_ID_WMV3)
03032 {
03033 int count = 0;
03034
03035
03036
03037
03038
03039
03040 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
03041
03042 if (vc1_decode_sequence_header(avctx, v, &gb) < 0)
03043 return -1;
03044
03045 count = avctx->extradata_size*8 - get_bits_count(&gb);
03046 if (count>0)
03047 {
03048 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
03049 count, get_bits(&gb, count));
03050 }
03051 else if (count < 0)
03052 {
03053 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
03054 }
03055 } else {
03056 const uint8_t *start = avctx->extradata;
03057 uint8_t *end = avctx->extradata + avctx->extradata_size;
03058 const uint8_t *next;
03059 int size, buf2_size;
03060 uint8_t *buf2 = NULL;
03061 int seq_initialized = 0, ep_initialized = 0;
03062
03063 if(avctx->extradata_size < 16) {
03064 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
03065 return -1;
03066 }
03067
03068 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
03069 start = find_next_marker(start, end);
03070 next = start;
03071 for(; next < end; start = next){
03072 next = find_next_marker(start + 4, end);
03073 size = next - start - 4;
03074 if(size <= 0) continue;
03075 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
03076 init_get_bits(&gb, buf2, buf2_size * 8);
03077 switch(AV_RB32(start)){
03078 case VC1_CODE_SEQHDR:
03079 if(vc1_decode_sequence_header(avctx, v, &gb) < 0){
03080 av_free(buf2);
03081 return -1;
03082 }
03083 seq_initialized = 1;
03084 break;
03085 case