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(VC1Context *v, int pq)
00164 {
00165 MpegEncContext *s = &v->s;
00166 int j;
00167 if (!s->first_slice_line) {
00168 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
00169 if (s->mb_x)
00170 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16*s->linesize, s->linesize, pq);
00171 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16*s->linesize+8, s->linesize, pq);
00172 for(j = 0; j < 2; j++){
00173 v->vc1dsp.vc1_v_loop_filter8(s->dest[j+1], s->uvlinesize, pq);
00174 if (s->mb_x)
00175 v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1]-8*s->uvlinesize, s->uvlinesize, pq);
00176 }
00177 }
00178 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8*s->linesize, s->linesize, pq);
00179
00180 if (s->mb_y == s->mb_height-1) {
00181 if (s->mb_x) {
00182 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
00183 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
00184 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
00185 }
00186 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
00187 }
00188 }
00189
00193 static void vc1_mc_1mv(VC1Context *v, int dir)
00194 {
00195 MpegEncContext *s = &v->s;
00196 DSPContext *dsp = &v->s.dsp;
00197 uint8_t *srcY, *srcU, *srcV;
00198 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
00199
00200 if(!v->s.last_picture.data[0])return;
00201
00202 mx = s->mv[dir][0][0];
00203 my = s->mv[dir][0][1];
00204
00205
00206 if(s->pict_type == FF_P_TYPE) {
00207 s->current_picture.motion_val[1][s->block_index[0]][0] = mx;
00208 s->current_picture.motion_val[1][s->block_index[0]][1] = my;
00209 }
00210 uvmx = (mx + ((mx & 3) == 3)) >> 1;
00211 uvmy = (my + ((my & 3) == 3)) >> 1;
00212 if(v->fastuvmc) {
00213 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
00214 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
00215 }
00216 if(!dir) {
00217 srcY = s->last_picture.data[0];
00218 srcU = s->last_picture.data[1];
00219 srcV = s->last_picture.data[2];
00220 } else {
00221 srcY = s->next_picture.data[0];
00222 srcU = s->next_picture.data[1];
00223 srcV = s->next_picture.data[2];
00224 }
00225
00226 src_x = s->mb_x * 16 + (mx >> 2);
00227 src_y = s->mb_y * 16 + (my >> 2);
00228 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00229 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00230
00231 if(v->profile != PROFILE_ADVANCED){
00232 src_x = av_clip( src_x, -16, s->mb_width * 16);
00233 src_y = av_clip( src_y, -16, s->mb_height * 16);
00234 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
00235 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00236 }else{
00237 src_x = av_clip( src_x, -17, s->avctx->coded_width);
00238 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
00239 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
00240 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00241 }
00242
00243 srcY += src_y * s->linesize + src_x;
00244 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
00245 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
00246
00247
00248 if(s->flags & CODEC_FLAG_GRAY) {
00249 srcU = s->edge_emu_buffer + 18 * s->linesize;
00250 srcV = s->edge_emu_buffer + 18 * s->linesize;
00251 }
00252
00253 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00254 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
00255 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
00256 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
00257
00258 srcY -= s->mspel * (1 + s->linesize);
00259 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
00260 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
00261 srcY = s->edge_emu_buffer;
00262 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
00263 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00264 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
00265 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00266 srcU = uvbuf;
00267 srcV = uvbuf + 16;
00268
00269 if(v->rangeredfrm) {
00270 int i, j;
00271 uint8_t *src, *src2;
00272
00273 src = srcY;
00274 for(j = 0; j < 17 + s->mspel*2; j++) {
00275 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
00276 src += s->linesize;
00277 }
00278 src = srcU; src2 = srcV;
00279 for(j = 0; j < 9; j++) {
00280 for(i = 0; i < 9; i++) {
00281 src[i] = ((src[i] - 128) >> 1) + 128;
00282 src2[i] = ((src2[i] - 128) >> 1) + 128;
00283 }
00284 src += s->uvlinesize;
00285 src2 += s->uvlinesize;
00286 }
00287 }
00288
00289 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00290 int i, j;
00291 uint8_t *src, *src2;
00292
00293 src = srcY;
00294 for(j = 0; j < 17 + s->mspel*2; j++) {
00295 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
00296 src += s->linesize;
00297 }
00298 src = srcU; src2 = srcV;
00299 for(j = 0; j < 9; j++) {
00300 for(i = 0; i < 9; i++) {
00301 src[i] = v->lutuv[src[i]];
00302 src2[i] = v->lutuv[src2[i]];
00303 }
00304 src += s->uvlinesize;
00305 src2 += s->uvlinesize;
00306 }
00307 }
00308 srcY += s->mspel * (1 + s->linesize);
00309 }
00310
00311 if(s->mspel) {
00312 dxy = ((my & 3) << 2) | (mx & 3);
00313 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
00314 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
00315 srcY += s->linesize * 8;
00316 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
00317 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
00318 } else {
00319 dxy = (my & 2) | ((mx & 2) >> 1);
00320
00321 if(!v->rnd)
00322 dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00323 else
00324 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00325 }
00326
00327 if(s->flags & CODEC_FLAG_GRAY) return;
00328
00329 uvmx = (uvmx&3)<<1;
00330 uvmy = (uvmy&3)<<1;
00331 if(!v->rnd){
00332 dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00333 dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00334 }else{
00335 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00336 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00337 }
00338 }
00339
00342 static void vc1_mc_4mv_luma(VC1Context *v, int n)
00343 {
00344 MpegEncContext *s = &v->s;
00345 DSPContext *dsp = &v->s.dsp;
00346 uint8_t *srcY;
00347 int dxy, mx, my, src_x, src_y;
00348 int off;
00349
00350 if(!v->s.last_picture.data[0])return;
00351 mx = s->mv[0][n][0];
00352 my = s->mv[0][n][1];
00353 srcY = s->last_picture.data[0];
00354
00355 off = s->linesize * 4 * (n&2) + (n&1) * 8;
00356
00357 src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
00358 src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
00359
00360 if(v->profile != PROFILE_ADVANCED){
00361 src_x = av_clip( src_x, -16, s->mb_width * 16);
00362 src_y = av_clip( src_y, -16, s->mb_height * 16);
00363 }else{
00364 src_x = av_clip( src_x, -17, s->avctx->coded_width);
00365 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
00366 }
00367
00368 srcY += src_y * s->linesize + src_x;
00369
00370 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00371 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
00372 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
00373 srcY -= s->mspel * (1 + s->linesize);
00374 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
00375 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
00376 srcY = s->edge_emu_buffer;
00377
00378 if(v->rangeredfrm) {
00379 int i, j;
00380 uint8_t *src;
00381
00382 src = srcY;
00383 for(j = 0; j < 9 + s->mspel*2; j++) {
00384 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
00385 src += s->linesize;
00386 }
00387 }
00388
00389 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00390 int i, j;
00391 uint8_t *src;
00392
00393 src = srcY;
00394 for(j = 0; j < 9 + s->mspel*2; j++) {
00395 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
00396 src += s->linesize;
00397 }
00398 }
00399 srcY += s->mspel * (1 + s->linesize);
00400 }
00401
00402 if(s->mspel) {
00403 dxy = ((my & 3) << 2) | (mx & 3);
00404 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
00405 } else {
00406 dxy = (my & 2) | ((mx & 2) >> 1);
00407 if(!v->rnd)
00408 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00409 else
00410 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00411 }
00412 }
00413
00414 static inline int median4(int a, int b, int c, int d)
00415 {
00416 if(a < b) {
00417 if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
00418 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
00419 } else {
00420 if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
00421 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
00422 }
00423 }
00424
00425
00428 static void vc1_mc_4mv_chroma(VC1Context *v)
00429 {
00430 MpegEncContext *s = &v->s;
00431 DSPContext *dsp = &v->s.dsp;
00432 uint8_t *srcU, *srcV;
00433 int uvmx, uvmy, uvsrc_x, uvsrc_y;
00434 int i, idx, tx = 0, ty = 0;
00435 int mvx[4], mvy[4], intra[4];
00436 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
00437
00438 if(!v->s.last_picture.data[0])return;
00439 if(s->flags & CODEC_FLAG_GRAY) return;
00440
00441 for(i = 0; i < 4; i++) {
00442 mvx[i] = s->mv[0][i][0];
00443 mvy[i] = s->mv[0][i][1];
00444 intra[i] = v->mb_type[0][s->block_index[i]];
00445 }
00446
00447
00448 idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
00449 if(!idx) {
00450 tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
00451 ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
00452 } else if(count[idx] == 1) {
00453 switch(idx) {
00454 case 0x1:
00455 tx = mid_pred(mvx[1], mvx[2], mvx[3]);
00456 ty = mid_pred(mvy[1], mvy[2], mvy[3]);
00457 break;
00458 case 0x2:
00459 tx = mid_pred(mvx[0], mvx[2], mvx[3]);
00460 ty = mid_pred(mvy[0], mvy[2], mvy[3]);
00461 break;
00462 case 0x4:
00463 tx = mid_pred(mvx[0], mvx[1], mvx[3]);
00464 ty = mid_pred(mvy[0], mvy[1], mvy[3]);
00465 break;
00466 case 0x8:
00467 tx = mid_pred(mvx[0], mvx[1], mvx[2]);
00468 ty = mid_pred(mvy[0], mvy[1], mvy[2]);
00469 break;
00470 }
00471 } else if(count[idx] == 2) {
00472 int t1 = 0, t2 = 0;
00473 for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
00474 for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
00475 tx = (mvx[t1] + mvx[t2]) / 2;
00476 ty = (mvy[t1] + mvy[t2]) / 2;
00477 } else {
00478 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
00479 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
00480 return;
00481 }
00482
00483 s->current_picture.motion_val[1][s->block_index[0]][0] = tx;
00484 s->current_picture.motion_val[1][s->block_index[0]][1] = ty;
00485 uvmx = (tx + ((tx&3) == 3)) >> 1;
00486 uvmy = (ty + ((ty&3) == 3)) >> 1;
00487 if(v->fastuvmc) {
00488 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
00489 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
00490 }
00491
00492 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00493 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00494
00495 if(v->profile != PROFILE_ADVANCED){
00496 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
00497 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00498 }else{
00499 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
00500 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00501 }
00502
00503 srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00504 srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00505 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00506 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
00507 || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
00508 s->dsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize, 8+1, 8+1,
00509 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00510 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
00511 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00512 srcU = s->edge_emu_buffer;
00513 srcV = s->edge_emu_buffer + 16;
00514
00515
00516 if(v->rangeredfrm) {
00517 int i, j;
00518 uint8_t *src, *src2;
00519
00520 src = srcU; src2 = srcV;
00521 for(j = 0; j < 9; j++) {
00522 for(i = 0; i < 9; i++) {
00523 src[i] = ((src[i] - 128) >> 1) + 128;
00524 src2[i] = ((src2[i] - 128) >> 1) + 128;
00525 }
00526 src += s->uvlinesize;
00527 src2 += s->uvlinesize;
00528 }
00529 }
00530
00531 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00532 int i, j;
00533 uint8_t *src, *src2;
00534
00535 src = srcU; src2 = srcV;
00536 for(j = 0; j < 9; j++) {
00537 for(i = 0; i < 9; i++) {
00538 src[i] = v->lutuv[src[i]];
00539 src2[i] = v->lutuv[src2[i]];
00540 }
00541 src += s->uvlinesize;
00542 src2 += s->uvlinesize;
00543 }
00544 }
00545 }
00546
00547
00548 uvmx = (uvmx&3)<<1;
00549 uvmy = (uvmy&3)<<1;
00550 if(!v->rnd){
00551 dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00552 dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00553 }else{
00554 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00555 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00556 }
00557 }
00558
00559
00570 #define GET_MQUANT() \
00571 if (v->dquantfrm) \
00572 { \
00573 int edges = 0; \
00574 if (v->dqprofile == DQPROFILE_ALL_MBS) \
00575 { \
00576 if (v->dqbilevel) \
00577 { \
00578 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
00579 } \
00580 else \
00581 { \
00582 mqdiff = get_bits(gb, 3); \
00583 if (mqdiff != 7) mquant = v->pq + mqdiff; \
00584 else mquant = get_bits(gb, 5); \
00585 } \
00586 } \
00587 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
00588 edges = 1 << v->dqsbedge; \
00589 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
00590 edges = (3 << v->dqsbedge) % 15; \
00591 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
00592 edges = 15; \
00593 if((edges&1) && !s->mb_x) \
00594 mquant = v->altpq; \
00595 if((edges&2) && s->first_slice_line) \
00596 mquant = v->altpq; \
00597 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
00598 mquant = v->altpq; \
00599 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
00600 mquant = v->altpq; \
00601 }
00602
00610 #define GET_MVDATA(_dmv_x, _dmv_y) \
00611 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table,\
00612 VC1_MV_DIFF_VLC_BITS, 2); \
00613 if (index > 36) \
00614 { \
00615 mb_has_coeffs = 1; \
00616 index -= 37; \
00617 } \
00618 else mb_has_coeffs = 0; \
00619 s->mb_intra = 0; \
00620 if (!index) { _dmv_x = _dmv_y = 0; } \
00621 else if (index == 35) \
00622 { \
00623 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
00624 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
00625 } \
00626 else if (index == 36) \
00627 { \
00628 _dmv_x = 0; \
00629 _dmv_y = 0; \
00630 s->mb_intra = 1; \
00631 } \
00632 else \
00633 { \
00634 index1 = index%6; \
00635 if (!s->quarter_sample && index1 == 5) val = 1; \
00636 else val = 0; \
00637 if(size_table[index1] - val > 0) \
00638 val = get_bits(gb, size_table[index1] - val); \
00639 else val = 0; \
00640 sign = 0 - (val&1); \
00641 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
00642 \
00643 index1 = index/6; \
00644 if (!s->quarter_sample && index1 == 5) val = 1; \
00645 else val = 0; \
00646 if(size_table[index1] - val > 0) \
00647 val = get_bits(gb, size_table[index1] - val); \
00648 else val = 0; \
00649 sign = 0 - (val&1); \
00650 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
00651 }
00652
00655 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)
00656 {
00657 int xy, wrap, off = 0;
00658 int16_t *A, *B, *C;
00659 int px, py;
00660 int sum;
00661
00662
00663 dmv_x <<= 1 - s->quarter_sample;
00664 dmv_y <<= 1 - s->quarter_sample;
00665
00666 wrap = s->b8_stride;
00667 xy = s->block_index[n];
00668
00669 if(s->mb_intra){
00670 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
00671 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
00672 s->current_picture.motion_val[1][xy][0] = 0;
00673 s->current_picture.motion_val[1][xy][1] = 0;
00674 if(mv1) {
00675 s->current_picture.motion_val[0][xy + 1][0] = 0;
00676 s->current_picture.motion_val[0][xy + 1][1] = 0;
00677 s->current_picture.motion_val[0][xy + wrap][0] = 0;
00678 s->current_picture.motion_val[0][xy + wrap][1] = 0;
00679 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
00680 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
00681 s->current_picture.motion_val[1][xy + 1][0] = 0;
00682 s->current_picture.motion_val[1][xy + 1][1] = 0;
00683 s->current_picture.motion_val[1][xy + wrap][0] = 0;
00684 s->current_picture.motion_val[1][xy + wrap][1] = 0;
00685 s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
00686 s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
00687 }
00688 return;
00689 }
00690
00691 C = s->current_picture.motion_val[0][xy - 1];
00692 A = s->current_picture.motion_val[0][xy - wrap];
00693 if(mv1)
00694 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
00695 else {
00696
00697 switch(n){
00698 case 0:
00699 off = (s->mb_x > 0) ? -1 : 1;
00700 break;
00701 case 1:
00702 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
00703 break;
00704 case 2:
00705 off = 1;
00706 break;
00707 case 3:
00708 off = -1;
00709 }
00710 }
00711 B = s->current_picture.motion_val[0][xy - wrap + off];
00712
00713 if(!s->first_slice_line || (n==2 || n==3)) {
00714 if(s->mb_width == 1) {
00715 px = A[0];
00716 py = A[1];
00717 } else {
00718 px = mid_pred(A[0], B[0], C[0]);
00719 py = mid_pred(A[1], B[1], C[1]);
00720 }
00721 } else if(s->mb_x || (n==1 || n==3)) {
00722 px = C[0];
00723 py = C[1];
00724 } else {
00725 px = py = 0;
00726 }
00727
00728 {
00729 int qx, qy, X, Y;
00730 qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
00731 qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
00732 X = (s->mb_width << 6) - 4;
00733 Y = (s->mb_height << 6) - 4;
00734 if(mv1) {
00735 if(qx + px < -60) px = -60 - qx;
00736 if(qy + py < -60) py = -60 - qy;
00737 } else {
00738 if(qx + px < -28) px = -28 - qx;
00739 if(qy + py < -28) py = -28 - qy;
00740 }
00741 if(qx + px > X) px = X - qx;
00742 if(qy + py > Y) py = Y - qy;
00743 }
00744
00745 if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
00746 if(is_intra[xy - wrap])
00747 sum = FFABS(px) + FFABS(py);
00748 else
00749 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
00750 if(sum > 32) {
00751 if(get_bits1(&s->gb)) {
00752 px = A[0];
00753 py = A[1];
00754 } else {
00755 px = C[0];
00756 py = C[1];
00757 }
00758 } else {
00759 if(is_intra[xy - 1])
00760 sum = FFABS(px) + FFABS(py);
00761 else
00762 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
00763 if(sum > 32) {
00764 if(get_bits1(&s->gb)) {
00765 px = A[0];
00766 py = A[1];
00767 } else {
00768 px = C[0];
00769 py = C[1];
00770 }
00771 }
00772 }
00773 }
00774
00775 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
00776 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
00777 if(mv1) {
00778 s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
00779 s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
00780 s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
00781 s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
00782 s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
00783 s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
00784 }
00785 }
00786
00789 static void vc1_interp_mc(VC1Context *v)
00790 {
00791 MpegEncContext *s = &v->s;
00792 DSPContext *dsp = &v->s.dsp;
00793 uint8_t *srcY, *srcU, *srcV;
00794 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
00795
00796 if(!v->s.next_picture.data[0])return;
00797
00798 mx = s->mv[1][0][0];
00799 my = s->mv[1][0][1];
00800 uvmx = (mx + ((mx & 3) == 3)) >> 1;
00801 uvmy = (my + ((my & 3) == 3)) >> 1;
00802 if(v->fastuvmc) {
00803 uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
00804 uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
00805 }
00806 srcY = s->next_picture.data[0];
00807 srcU = s->next_picture.data[1];
00808 srcV = s->next_picture.data[2];
00809
00810 src_x = s->mb_x * 16 + (mx >> 2);
00811 src_y = s->mb_y * 16 + (my >> 2);
00812 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00813 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00814
00815 if(v->profile != PROFILE_ADVANCED){
00816 src_x = av_clip( src_x, -16, s->mb_width * 16);
00817 src_y = av_clip( src_y, -16, s->mb_height * 16);
00818 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
00819 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00820 }else{
00821 src_x = av_clip( src_x, -17, s->avctx->coded_width);
00822 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
00823 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
00824 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00825 }
00826
00827 srcY += src_y * s->linesize + src_x;
00828 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
00829 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
00830
00831
00832 if(s->flags & CODEC_FLAG_GRAY) {
00833 srcU = s->edge_emu_buffer + 18 * s->linesize;
00834 srcV = s->edge_emu_buffer + 18 * s->linesize;
00835 }
00836
00837 if(v->rangeredfrm
00838 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
00839 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
00840 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
00841
00842 srcY -= s->mspel * (1 + s->linesize);
00843 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
00844 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
00845 srcY = s->edge_emu_buffer;
00846 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
00847 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00848 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
00849 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00850 srcU = uvbuf;
00851 srcV = uvbuf + 16;
00852
00853 if(v->rangeredfrm) {
00854 int i, j;
00855 uint8_t *src, *src2;
00856
00857 src = srcY;
00858 for(j = 0; j < 17 + s->mspel*2; j++) {
00859 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
00860 src += s->linesize;
00861 }
00862 src = srcU; src2 = srcV;
00863 for(j = 0; j < 9; j++) {
00864 for(i = 0; i < 9; i++) {
00865 src[i] = ((src[i] - 128) >> 1) + 128;
00866 src2[i] = ((src2[i] - 128) >> 1) + 128;
00867 }
00868 src += s->uvlinesize;
00869 src2 += s->uvlinesize;
00870 }
00871 }
00872 srcY += s->mspel * (1 + s->linesize);
00873 }
00874
00875 if(s->mspel) {
00876 dxy = ((my & 3) << 2) | (mx & 3);
00877 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
00878 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
00879 srcY += s->linesize * 8;
00880 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
00881 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
00882 } else {
00883 dxy = (my & 2) | ((mx & 2) >> 1);
00884
00885 if(!v->rnd)
00886 dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00887 else
00888 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00889 }
00890
00891 if(s->flags & CODEC_FLAG_GRAY) return;
00892
00893 uvmx = (uvmx&3)<<1;
00894 uvmy = (uvmy&3)<<1;
00895 if(!v->rnd){
00896 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00897 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00898 }else{
00899 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00900 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00901 }
00902 }
00903
00904 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
00905 {
00906 int n = bfrac;
00907
00908 #if B_FRACTION_DEN==256
00909 if(inv)
00910 n -= 256;
00911 if(!qs)
00912 return 2 * ((value * n + 255) >> 9);
00913 return (value * n + 128) >> 8;
00914 #else
00915 if(inv)
00916 n -= B_FRACTION_DEN;
00917 if(!qs)
00918 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
00919 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
00920 #endif
00921 }
00922
00925 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
00926 {
00927 if(v->use_ic) {
00928 v->mv_mode2 = v->mv_mode;
00929 v->mv_mode = MV_PMODE_INTENSITY_COMP;
00930 }
00931 if(direct) {
00932 vc1_mc_1mv(v, 0);
00933 vc1_interp_mc(v);
00934 if(v->use_ic) v->mv_mode = v->mv_mode2;
00935 return;
00936 }
00937 if(mode == BMV_TYPE_INTERPOLATED) {
00938 vc1_mc_1mv(v, 0);
00939 vc1_interp_mc(v);
00940 if(v->use_ic) v->mv_mode = v->mv_mode2;
00941 return;
00942 }
00943
00944 if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
00945 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
00946 if(v->use_ic) v->mv_mode = v->mv_mode2;
00947 }
00948
00949 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
00950 {
00951 MpegEncContext *s = &v->s;
00952 int xy, wrap, off = 0;
00953 int16_t *A, *B, *C;
00954 int px, py;
00955 int sum;
00956 int r_x, r_y;
00957 const uint8_t *is_intra = v->mb_type[0];
00958
00959 r_x = v->range_x;
00960 r_y = v->range_y;
00961
00962 dmv_x[0] <<= 1 - s->quarter_sample;
00963 dmv_y[0] <<= 1 - s->quarter_sample;
00964 dmv_x[1] <<= 1 - s->quarter_sample;
00965 dmv_y[1] <<= 1 - s->quarter_sample;
00966
00967 wrap = s->b8_stride;
00968 xy = s->block_index[0];
00969
00970 if(s->mb_intra) {
00971 s->current_picture.motion_val[0][xy][0] =
00972 s->current_picture.motion_val[0][xy][1] =
00973 s->current_picture.motion_val[1][xy][0] =
00974 s->current_picture.motion_val[1][xy][1] = 0;
00975 return;
00976 }
00977 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
00978 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
00979 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
00980 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
00981
00982
00983 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));
00984 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));
00985 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));
00986 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));
00987 if(direct) {
00988 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
00989 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
00990 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
00991 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
00992 return;
00993 }
00994
00995 if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
00996 C = s->current_picture.motion_val[0][xy - 2];
00997 A = s->current_picture.motion_val[0][xy - wrap*2];
00998 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
00999 B = s->current_picture.motion_val[0][xy - wrap*2 + off];
01000
01001 if(!s->mb_x) C[0] = C[1] = 0;
01002 if(!s->first_slice_line) {
01003 if(s->mb_width == 1) {
01004 px = A[0];
01005 py = A[1];
01006 } else {
01007 px = mid_pred(A[0], B[0], C[0]);
01008 py = mid_pred(A[1], B[1], C[1]);
01009 }
01010 } else if(s->mb_x) {
01011 px = C[0];
01012 py = C[1];
01013 } else {
01014 px = py = 0;
01015 }
01016
01017 {
01018 int qx, qy, X, Y;
01019 if(v->profile < PROFILE_ADVANCED) {
01020 qx = (s->mb_x << 5);
01021 qy = (s->mb_y << 5);
01022 X = (s->mb_width << 5) - 4;
01023 Y = (s->mb_height << 5) - 4;
01024 if(qx + px < -28) px = -28 - qx;
01025 if(qy + py < -28) py = -28 - qy;
01026 if(qx + px > X) px = X - qx;
01027 if(qy + py > Y) py = Y - qy;
01028 } else {
01029 qx = (s->mb_x << 6);
01030 qy = (s->mb_y << 6);
01031 X = (s->mb_width << 6) - 4;
01032 Y = (s->mb_height << 6) - 4;
01033 if(qx + px < -60) px = -60 - qx;
01034 if(qy + py < -60) py = -60 - qy;
01035 if(qx + px > X) px = X - qx;
01036 if(qy + py > Y) py = Y - qy;
01037 }
01038 }
01039
01040 if(0 && !s->first_slice_line && s->mb_x) {
01041 if(is_intra[xy - wrap])
01042 sum = FFABS(px) + FFABS(py);
01043 else
01044 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
01045 if(sum > 32) {
01046 if(get_bits1(&s->gb)) {
01047 px = A[0];
01048 py = A[1];
01049 } else {
01050 px = C[0];
01051 py = C[1];
01052 }
01053 } else {
01054 if(is_intra[xy - 2])
01055 sum = FFABS(px) + FFABS(py);
01056 else
01057 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
01058 if(sum > 32) {
01059 if(get_bits1(&s->gb)) {
01060 px = A[0];
01061 py = A[1];
01062 } else {
01063 px = C[0];
01064 py = C[1];
01065 }
01066 }
01067 }
01068 }
01069
01070 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
01071 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
01072 }
01073 if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
01074 C = s->current_picture.motion_val[1][xy - 2];
01075 A = s->current_picture.motion_val[1][xy - wrap*2];
01076 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
01077 B = s->current_picture.motion_val[1][xy - wrap*2 + off];
01078
01079 if(!s->mb_x) C[0] = C[1] = 0;
01080 if(!s->first_slice_line) {
01081 if(s->mb_width == 1) {
01082 px = A[0];
01083 py = A[1];
01084 } else {
01085 px = mid_pred(A[0], B[0], C[0]);
01086 py = mid_pred(A[1], B[1], C[1]);
01087 }
01088 } else if(s->mb_x) {
01089 px = C[0];
01090 py = C[1];
01091 } else {
01092 px = py = 0;
01093 }
01094
01095 {
01096 int qx, qy, X, Y;
01097 if(v->profile < PROFILE_ADVANCED) {
01098 qx = (s->mb_x << 5);
01099 qy = (s->mb_y << 5);
01100 X = (s->mb_width << 5) - 4;
01101 Y = (s->mb_height << 5) - 4;
01102 if(qx + px < -28) px = -28 - qx;
01103 if(qy + py < -28) py = -28 - qy;
01104 if(qx + px > X) px = X - qx;
01105 if(qy + py > Y) py = Y - qy;
01106 } else {
01107 qx = (s->mb_x << 6);
01108 qy = (s->mb_y << 6);
01109 X = (s->mb_width << 6) - 4;
01110 Y = (s->mb_height << 6) - 4;
01111 if(qx + px < -60) px = -60 - qx;
01112 if(qy + py < -60) py = -60 - qy;
01113 if(qx + px > X) px = X - qx;
01114 if(qy + py > Y) py = Y - qy;
01115 }
01116 }
01117
01118 if(0 && !s->first_slice_line && s->mb_x) {
01119 if(is_intra[xy - wrap])
01120 sum = FFABS(px) + FFABS(py);
01121 else
01122 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
01123 if(sum > 32) {
01124 if(get_bits1(&s->gb)) {
01125 px = A[0];
01126 py = A[1];
01127 } else {
01128 px = C[0];
01129 py = C[1];
01130 }
01131 } else {
01132 if(is_intra[xy - 2])
01133 sum = FFABS(px) + FFABS(py);
01134 else
01135 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
01136 if(sum > 32) {
01137 if(get_bits1(&s->gb)) {
01138 px = A[0];
01139 py = A[1];
01140 } else {
01141 px = C[0];
01142 py = C[1];
01143 }
01144 }
01145 }
01146 }
01147
01148
01149 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
01150 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
01151 }
01152 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
01153 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
01154 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
01155 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
01156 }
01157
01167 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
01168 int16_t **dc_val_ptr, int *dir_ptr)
01169 {
01170 int a, b, c, wrap, pred, scale;
01171 int16_t *dc_val;
01172 static const uint16_t dcpred[32] = {
01173 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
01174 114, 102, 93, 85, 79, 73, 68, 64,
01175 60, 57, 54, 51, 49, 47, 45, 43,
01176 41, 39, 38, 37, 35, 34, 33
01177 };
01178
01179
01180 if (n < 4) scale = s->y_dc_scale;
01181 else scale = s->c_dc_scale;
01182
01183 wrap = s->block_wrap[n];
01184 dc_val= s->dc_val[0] + s->block_index[n];
01185
01186
01187
01188
01189 c = dc_val[ - 1];
01190 b = dc_val[ - 1 - wrap];
01191 a = dc_val[ - wrap];
01192
01193 if (pq < 9 || !overlap)
01194 {
01195
01196 if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
01197 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
01198 }
01199 else
01200 {
01201
01202 if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
01203 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
01204 }
01205
01206 if (abs(a - b) <= abs(b - c)) {
01207 pred = c;
01208 *dir_ptr = 1;
01209 } else {
01210 pred = a;
01211 *dir_ptr = 0;
01212 }
01213
01214
01215 *dc_val_ptr = &dc_val[0];
01216 return pred;
01217 }
01218
01219
01231 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
01232 int a_avail, int c_avail,
01233 int16_t **dc_val_ptr, int *dir_ptr)
01234 {
01235 int a, b, c, wrap, pred;
01236 int16_t *dc_val;
01237 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01238 int q1, q2 = 0;
01239
01240 wrap = s->block_wrap[n];
01241 dc_val= s->dc_val[0] + s->block_index[n];
01242
01243
01244
01245
01246 c = dc_val[ - 1];
01247 b = dc_val[ - 1 - wrap];
01248 a = dc_val[ - wrap];
01249
01250 q1 = s->current_picture.qscale_table[mb_pos];
01251 if(c_avail && (n!= 1 && n!=3)) {
01252 q2 = s->current_picture.qscale_table[mb_pos - 1];
01253 if(q2 && q2 != q1)
01254 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
01255 }
01256 if(a_avail && (n!= 2 && n!=3)) {
01257 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
01258 if(q2 && q2 != q1)
01259 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
01260 }
01261 if(a_avail && c_avail && (n!=3)) {
01262 int off = mb_pos;
01263 if(n != 1) off--;
01264 if(n != 2) off -= s->mb_stride;
01265 q2 = s->current_picture.qscale_table[off];
01266 if(q2 && q2 != q1)
01267 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
01268 }
01269
01270 if(a_avail && c_avail) {
01271 if(abs(a - b) <= abs(b - c)) {
01272 pred = c;
01273 *dir_ptr = 1;
01274 } else {
01275 pred = a;
01276 *dir_ptr = 0;
01277 }
01278 } else if(a_avail) {
01279 pred = a;
01280 *dir_ptr = 0;
01281 } else if(c_avail) {
01282 pred = c;
01283 *dir_ptr = 1;
01284 } else {
01285 pred = 0;
01286 *dir_ptr = 1;
01287 }
01288
01289
01290 *dc_val_ptr = &dc_val[0];
01291 return pred;
01292 }
01293
01295
01302 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
01303 {
01304 int xy, wrap, pred, a, b, c;
01305
01306 xy = s->block_index[n];
01307 wrap = s->b8_stride;
01308
01309
01310
01311
01312 a = s->coded_block[xy - 1 ];
01313 b = s->coded_block[xy - 1 - wrap];
01314 c = s->coded_block[xy - wrap];
01315
01316 if (b == c) {
01317 pred = a;
01318 } else {
01319 pred = c;
01320 }
01321
01322
01323 *coded_block_ptr = &s->coded_block[xy];
01324
01325 return pred;
01326 }
01327
01337 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
01338 {
01339 GetBitContext *gb = &v->s.gb;
01340 int index, escape, run = 0, level = 0, lst = 0;
01341
01342 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
01343 if (index != vc1_ac_sizes[codingset] - 1) {
01344 run = vc1_index_decode_table[codingset][index][0];
01345 level = vc1_index_decode_table[codingset][index][1];
01346 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
01347 if(get_bits1(gb))
01348 level = -level;
01349 } else {
01350 escape = decode210(gb);
01351 if (escape != 2) {
01352 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
01353 run = vc1_index_decode_table[codingset][index][0];
01354 level = vc1_index_decode_table[codingset][index][1];
01355 lst = index >= vc1_last_decode_table[codingset];
01356 if(escape == 0) {
01357 if(lst)
01358 level += vc1_last_delta_level_table[codingset][run];
01359 else
01360 level += vc1_delta_level_table[codingset][run];
01361 } else {
01362 if(lst)
01363 run += vc1_last_delta_run_table[codingset][level] + 1;
01364 else
01365 run += vc1_delta_run_table[codingset][level] + 1;
01366 }
01367 if(get_bits1(gb))
01368 level = -level;
01369 } else {
01370 int sign;
01371 lst = get_bits1(gb);
01372 if(v->s.esc3_level_length == 0) {
01373 if(v->pq < 8 || v->dquantfrm) {
01374 v->s.esc3_level_length = get_bits(gb, 3);
01375 if(!v->s.esc3_level_length)
01376 v->s.esc3_level_length = get_bits(gb, 2) + 8;
01377 } else {
01378 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
01379 }
01380 v->s.esc3_run_length = 3 + get_bits(gb, 2);
01381 }
01382 run = get_bits(gb, v->s.esc3_run_length);
01383 sign = get_bits1(gb);
01384 level = get_bits(gb, v->s.esc3_level_length);
01385 if(sign)
01386 level = -level;
01387 }
01388 }
01389
01390 *last = lst;
01391 *skip = run;
01392 *value = level;
01393 }
01394
01402 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
01403 {
01404 GetBitContext *gb = &v->s.gb;
01405 MpegEncContext *s = &v->s;
01406 int dc_pred_dir = 0;
01407 int i;
01408 int16_t *dc_val;
01409 int16_t *ac_val, *ac_val2;
01410 int dcdiff;
01411
01412
01413 if (n < 4) {
01414 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01415 } else {
01416 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01417 }
01418 if (dcdiff < 0){
01419 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
01420 return -1;
01421 }
01422 if (dcdiff)
01423 {
01424 if (dcdiff == 119 )
01425 {
01426
01427 if (v->pq == 1) dcdiff = get_bits(gb, 10);
01428 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
01429 else dcdiff = get_bits(gb, 8);
01430 }
01431 else
01432 {
01433 if (v->pq == 1)
01434 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
01435 else if (v->pq == 2)
01436 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
01437 }
01438 if (get_bits1(gb))
01439 dcdiff = -dcdiff;
01440 }
01441
01442
01443 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
01444 *dc_val = dcdiff;
01445
01446
01447 if (n < 4) {
01448 block[0] = dcdiff * s->y_dc_scale;
01449 } else {
01450 block[0] = dcdiff * s->c_dc_scale;
01451 }
01452
01453 if (!coded) {
01454 goto not_coded;
01455 }
01456
01457
01458 i = 1;
01459
01460 {
01461 int last = 0, skip, value;
01462 const uint8_t *zz_table;
01463 int scale;
01464 int k;
01465
01466 scale = v->pq * 2 + v->halfpq;
01467
01468 if(v->s.ac_pred) {
01469 if(!dc_pred_dir)
01470 zz_table = v->zz_8x8[2];
01471 else
01472 zz_table = v->zz_8x8[3];
01473 } else
01474 zz_table = v->zz_8x8[1];
01475
01476 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01477 ac_val2 = ac_val;
01478 if(dc_pred_dir)
01479 ac_val -= 16;
01480 else
01481 ac_val -= 16 * s->block_wrap[n];
01482
01483 while (!last) {
01484 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
01485 i += skip;
01486 if(i > 63)
01487 break;
01488 block[zz_table[i++]] = value;
01489 }
01490
01491
01492 if(s->ac_pred) {
01493 if(dc_pred_dir) {
01494 for(k = 1; k < 8; k++)
01495 block[k] += ac_val[k];
01496 } else {
01497 for(k = 1; k < 8; k++)
01498 block[k << 3] += ac_val[k + 8];
01499 }
01500 }
01501
01502 for(k = 1; k < 8; k++) {
01503 ac_val2[k] = block[k];
01504 ac_val2[k + 8] = block[k << 3];
01505 }
01506
01507
01508 for(k = 1; k < 64; k++)
01509 if(block[k]) {
01510 block[k] *= scale;
01511 if(!v->pquantizer)
01512 block[k] += (block[k] < 0) ? -v->pq : v->pq;
01513 }
01514
01515 if(s->ac_pred) i = 63;
01516 }
01517
01518 not_coded:
01519 if(!coded) {
01520 int k, scale;
01521 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01522 ac_val2 = ac_val;
01523
01524 i = 0;
01525 scale = v->pq * 2 + v->halfpq;
01526 memset(ac_val2, 0, 16 * 2);
01527 if(dc_pred_dir) {
01528 ac_val -= 16;
01529 if(s->ac_pred)
01530 memcpy(ac_val2, ac_val, 8 * 2);
01531 } else {
01532 ac_val -= 16 * s->block_wrap[n];
01533 if(s->ac_pred)
01534 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
01535 }
01536
01537
01538 if(s->ac_pred) {
01539 if(dc_pred_dir) {
01540 for(k = 1; k < 8; k++) {
01541 block[k] = ac_val[k] * scale;
01542 if(!v->pquantizer && block[k])
01543 block[k] += (block[k] < 0) ? -v->pq : v->pq;
01544 }
01545 } else {
01546 for(k = 1; k < 8; k++) {
01547 block[k << 3] = ac_val[k + 8] * scale;
01548 if(!v->pquantizer && block[k << 3])
01549 block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
01550 }
01551 }
01552 i = 63;
01553 }
01554 }
01555 s->block_last_index[n] = i;
01556
01557 return 0;
01558 }
01559
01568 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
01569 {
01570 GetBitContext *gb = &v->s.gb;
01571 MpegEncContext *s = &v->s;
01572 int dc_pred_dir = 0;
01573 int i;
01574 int16_t *dc_val;
01575 int16_t *ac_val, *ac_val2;
01576 int dcdiff;
01577 int a_avail = v->a_avail, c_avail = v->c_avail;
01578 int use_pred = s->ac_pred;
01579 int scale;
01580 int q1, q2 = 0;
01581 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01582
01583
01584 if (n < 4) {
01585 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01586 } else {
01587 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01588 }
01589 if (dcdiff < 0){
01590 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
01591 return -1;
01592 }
01593 if (dcdiff)
01594 {
01595 if (dcdiff == 119 )
01596 {
01597
01598 if (mquant == 1) dcdiff = get_bits(gb, 10);
01599 else if (mquant == 2) dcdiff = get_bits(gb, 9);
01600 else dcdiff = get_bits(gb, 8);
01601 }
01602 else
01603 {
01604 if (mquant == 1)
01605 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
01606 else if (mquant == 2)
01607 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
01608 }
01609 if (get_bits1(gb))
01610 dcdiff = -dcdiff;
01611 }
01612
01613
01614 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
01615 *dc_val = dcdiff;
01616
01617
01618 if (n < 4) {
01619 block[0] = dcdiff * s->y_dc_scale;
01620 } else {
01621 block[0] = dcdiff * s->c_dc_scale;
01622 }
01623
01624
01625 i = 1;
01626
01627
01628 if(!a_avail && !c_avail) use_pred = 0;
01629 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01630 ac_val2 = ac_val;
01631
01632 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
01633
01634 if(dc_pred_dir)
01635 ac_val -= 16;
01636 else
01637 ac_val -= 16 * s->block_wrap[n];
01638
01639 q1 = s->current_picture.qscale_table[mb_pos];
01640 if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
01641 if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
01642 if(dc_pred_dir && n==1) q2 = q1;
01643 if(!dc_pred_dir && n==2) q2 = q1;
01644 if(n==3) q2 = q1;
01645
01646 if(coded) {
01647 int last = 0, skip, value;
01648 const uint8_t *zz_table;
01649 int k;
01650
01651 if(v->s.ac_pred) {
01652 if(!dc_pred_dir)
01653 zz_table = v->zz_8x8[2];
01654 else
01655 zz_table = v->zz_8x8[3];
01656 } else
01657 zz_table = v->zz_8x8[1];
01658
01659 while (!last) {
01660 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
01661 i += skip;
01662 if(i > 63)
01663 break;
01664 block[zz_table[i++]] = value;
01665 }
01666
01667
01668 if(use_pred) {
01669
01670 if(q2 && q1!=q2) {
01671 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01672 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01673
01674 if(dc_pred_dir) {
01675 for(k = 1; k < 8; k++)
01676 block[k] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01677 } else {
01678 for(k = 1; k < 8; k++)
01679 block[k << 3] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01680 }
01681 } else {
01682 if(dc_pred_dir) {
01683 for(k = 1; k < 8; k++)
01684 block[k] += ac_val[k];
01685 } else {
01686 for(k = 1; k < 8; k++)
01687 block[k << 3] += ac_val[k + 8];
01688 }
01689 }
01690 }
01691
01692 for(k = 1; k < 8; k++) {
01693 ac_val2[k] = block[k];
01694 ac_val2[k + 8] = block[k << 3];
01695 }
01696
01697
01698 for(k = 1; k < 64; k++)
01699 if(block[k]) {
01700 block[k] *= scale;
01701 if(!v->pquantizer)
01702 block[k] += (block[k] < 0) ? -mquant : mquant;
01703 }
01704
01705 if(use_pred) i = 63;
01706 } else {
01707 int k;
01708
01709 memset(ac_val2, 0, 16 * 2);
01710 if(dc_pred_dir) {
01711 if(use_pred) {
01712 memcpy(ac_val2, ac_val, 8 * 2);
01713 if(q2 && q1!=q2) {
01714 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01715 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01716 for(k = 1; k < 8; k++)
01717 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01718 }
01719 }
01720 } else {
01721 if(use_pred) {
01722 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
01723 if(q2 && q1!=q2) {
01724 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01725 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01726 for(k = 1; k < 8; k++)
01727 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01728 }
01729 }
01730 }
01731
01732
01733 if(use_pred) {
01734 if(dc_pred_dir) {
01735 for(k = 1; k < 8; k++) {
01736 block[k] = ac_val2[k] * scale;
01737 if(!v->pquantizer && block[k])
01738 block[k] += (block[k] < 0) ? -mquant : mquant;
01739 }
01740 } else {
01741 for(k = 1; k < 8; k++) {
01742 block[k << 3] = ac_val2[k + 8] * scale;
01743 if(!v->pquantizer && block[k << 3])
01744 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
01745 }
01746 }
01747 i = 63;
01748 }
01749 }
01750 s->block_last_index[n] = i;
01751
01752 return 0;
01753 }
01754
01763 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
01764 {
01765 GetBitContext *gb = &v->s.gb;
01766 MpegEncContext *s = &v->s;
01767 int dc_pred_dir = 0;
01768 int i;
01769 int16_t *dc_val;
01770 int16_t *ac_val, *ac_val2;
01771 int dcdiff;
01772 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01773 int a_avail = v->a_avail, c_avail = v->c_avail;
01774 int use_pred = s->ac_pred;
01775 int scale;
01776 int q1, q2 = 0;
01777
01778 s->dsp.clear_block(block);
01779
01780
01781 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
01782
01783
01784 s->y_dc_scale = s->y_dc_scale_table[mquant];
01785 s->c_dc_scale = s->c_dc_scale_table[mquant];
01786
01787
01788 if (n < 4) {
01789 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01790 } else {
01791 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01792 }
01793 if (dcdiff < 0){
01794 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
01795 return -1;
01796 }
01797 if (dcdiff)
01798 {
01799 if (dcdiff == 119 )
01800 {
01801
01802 if (mquant == 1) dcdiff = get_bits(gb, 10);
01803 else if (mquant == 2) dcdiff = get_bits(gb, 9);
01804 else dcdiff = get_bits(gb, 8);
01805 }
01806 else
01807 {
01808 if (mquant == 1)
01809 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
01810 else if (mquant == 2)
01811 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
01812 }
01813 if (get_bits1(gb))
01814 dcdiff = -dcdiff;
01815 }
01816
01817
01818 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
01819 *dc_val = dcdiff;
01820
01821
01822
01823 if (n < 4) {
01824 block[0] = dcdiff * s->y_dc_scale;
01825 } else {
01826 block[0] = dcdiff * s->c_dc_scale;
01827 }
01828
01829
01830 i = 1;
01831
01832
01833 if(!a_avail) dc_pred_dir = 1;
01834 if(!c_avail) dc_pred_dir = 0;
01835 if(!a_avail && !c_avail) use_pred = 0;
01836 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01837 ac_val2 = ac_val;
01838
01839 scale = mquant * 2 + v->halfpq;
01840
01841 if(dc_pred_dir)
01842 ac_val -= 16;
01843 else
01844 ac_val -= 16 * s->block_wrap[n];
01845
01846 q1 = s->current_picture.qscale_table[mb_pos];
01847 if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
01848 if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
01849 if(dc_pred_dir && n==1) q2 = q1;
01850 if(!dc_pred_dir && n==2) q2 = q1;
01851 if(n==3) q2 = q1;
01852
01853 if(coded) {
01854 int last = 0, skip, value;
01855 int k;
01856
01857 while (!last) {
01858 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
01859 i += skip;
01860 if(i > 63)
01861 break;
01862 block[v->zz_8x8[0][i++]] = value;
01863 }
01864
01865
01866 if(use_pred) {
01867
01868 if(q2 && q1!=q2) {
01869 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01870 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01871
01872 if(dc_pred_dir) {
01873 for(k = 1; k < 8; k++)
01874 block[k] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01875 } else {
01876 for(k = 1; k < 8; k++)
01877 block[k << 3] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01878 }
01879 } else {
01880 if(dc_pred_dir) {
01881 for(k = 1; k < 8; k++)
01882 block[k] += ac_val[k];
01883 } else {
01884 for(k = 1; k < 8; k++)
01885 block[k << 3] += ac_val[k + 8];
01886 }
01887 }
01888 }
01889
01890 for(k = 1; k < 8; k++) {
01891 ac_val2[k] = block[k];
01892 ac_val2[k + 8] = block[k << 3];
01893 }
01894
01895
01896 for(k = 1; k < 64; k++)
01897 if(block[k]) {
01898 block[k] *= scale;
01899 if(!v->pquantizer)
01900 block[k] += (block[k] < 0) ? -mquant : mquant;
01901 }
01902
01903 if(use_pred) i = 63;
01904 } else {
01905 int k;
01906
01907 memset(ac_val2, 0, 16 * 2);
01908 if(dc_pred_dir) {
01909 if(use_pred) {
01910 memcpy(ac_val2, ac_val, 8 * 2);
01911 if(q2 && q1!=q2) {
01912 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01913 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01914 for(k = 1; k < 8; k++)
01915 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01916 }
01917 }
01918 } else {
01919 if(use_pred) {
01920 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
01921 if(q2 && q1!=q2) {
01922 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01923 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01924 for(k = 1; k < 8; k++)
01925 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01926 }
01927 }
01928 }
01929
01930
01931 if(use_pred) {
01932 if(dc_pred_dir) {
01933 for(k = 1; k < 8; k++) {
01934 block[k] = ac_val2[k] * scale;
01935 if(!v->pquantizer && block[k])
01936 block[k] += (block[k] < 0) ? -mquant : mquant;
01937 }
01938 } else {
01939 for(k = 1; k < 8; k++) {
01940 block[k << 3] = ac_val2[k + 8] * scale;
01941 if(!v->pquantizer && block[k << 3])
01942 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
01943 }
01944 }
01945 i = 63;
01946 }
01947 }
01948 s->block_last_index[n] = i;
01949
01950 return 0;
01951 }
01952
01955 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block,
01956 uint8_t *dst, int linesize, int skip_block, int apply_filter, int cbp_top, int cbp_left)
01957 {
01958 MpegEncContext *s = &v->s;
01959 GetBitContext *gb = &s->gb;
01960 int i, j;
01961 int subblkpat = 0;
01962 int scale, off, idx, last, skip, value;
01963 int ttblk = ttmb & 7;
01964 int pat = 0;
01965
01966 s->dsp.clear_block(block);
01967
01968 if(ttmb == -1) {
01969 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)];
01970 }
01971 if(ttblk == TT_4X4) {
01972 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
01973 }
01974 if((ttblk != TT_8X8 && ttblk != TT_4X4)
01975 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
01976 || (!v->res_rtm_flag && !first_block))) {
01977 subblkpat = decode012(gb);
01978 if(subblkpat) subblkpat ^= 3;
01979 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
01980 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
01981 }
01982 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
01983
01984
01985 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
01986 subblkpat = 2 - (ttblk == TT_8X4_TOP);
01987 ttblk = TT_8X4;
01988 }
01989 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
01990 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
01991 ttblk = TT_4X8;
01992 }
01993 switch(ttblk) {
01994 case TT_8X8:
01995 pat = 0xF;
01996 i = 0;
01997 last = 0;
01998 while (!last) {
01999 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02000 i += skip;
02001 if(i > 63)
02002 break;
02003 idx = v->zz_8x8[0][i++];
02004 block[idx] = value * scale;
02005 if(!v->pquantizer)
02006 block[idx] += (block[idx] < 0) ? -mquant : mquant;
02007 }
02008 if(!skip_block){
02009 if(i==1)
02010 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
02011 else{
02012 v->vc1dsp.vc1_inv_trans_8x8_add(dst, linesize, block);
02013 }
02014 if(apply_filter && cbp_top & 0xC)
02015 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
02016 if(apply_filter && cbp_left & 0xA)
02017 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
02018 }
02019 break;
02020 case TT_4X4:
02021 pat = ~subblkpat & 0xF;
02022 for(j = 0; j < 4; j++) {
02023 last = subblkpat & (1 << (3 - j));
02024 i = 0;
02025 off = (j & 1) * 4 + (j & 2) * 16;
02026 while (!last) {
02027 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02028 i += skip;
02029 if(i > 15)
02030 break;
02031 idx = ff_vc1_simple_progressive_4x4_zz[i++];
02032 block[idx + off] = value * scale;
02033 if(!v->pquantizer)
02034 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
02035 }
02036 if(!(subblkpat & (1 << (3 - j))) && !skip_block){
02037 if(i==1)
02038 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off);
02039 else
02040 v->vc1dsp.vc1_inv_trans_4x4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off);
02041 if(apply_filter && (j&2 ? pat & (1<<(j-2)) : (cbp_top & (1 << (j + 2)))))
02042 v->vc1dsp.vc1_v_loop_filter4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, v->pq);
02043 if(apply_filter && (j&1 ? pat & (1<<(j-1)) : (cbp_left & (1 << (j + 1)))))
02044 v->vc1dsp.vc1_h_loop_filter4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, v->pq);
02045 }
02046 }
02047 break;
02048 case TT_8X4:
02049 pat = ~((subblkpat & 2)*6 + (subblkpat & 1)*3) & 0xF;
02050 for(j = 0; j < 2; j++) {
02051 last = subblkpat & (1 << (1 - j));
02052 i = 0;
02053 off = j * 32;
02054 while (!last) {
02055 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02056 i += skip;
02057 if(i > 31)
02058 break;
02059 idx = v->zz_8x4[i++]+off;
02060 block[idx] = value * scale;
02061 if(!v->pquantizer)
02062 block[idx] += (block[idx] < 0) ? -mquant : mquant;
02063 }
02064 if(!(subblkpat & (1 << (1 - j))) && !skip_block){
02065 if(i==1)
02066 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j*4*linesize, linesize, block + off);
02067 else
02068 v->vc1dsp.vc1_inv_trans_8x4(dst + j*4*linesize, linesize, block + off);
02069 if(apply_filter && j ? pat & 0x3 : (cbp_top & 0xC))
02070 v->vc1dsp.vc1_v_loop_filter8(dst + j*4*linesize, linesize, v->pq);
02071 if(apply_filter && cbp_left & (2 << j))
02072 v->vc1dsp.vc1_h_loop_filter4(dst + j*4*linesize, linesize, v->pq);
02073 }
02074 }
02075 break;
02076 case TT_4X8:
02077 pat = ~(subblkpat*5) & 0xF;
02078 for(j = 0; j < 2; j++) {
02079 last = subblkpat & (1 << (1 - j));
02080 i = 0;
02081 off = j * 4;
02082 while (!last) {
02083 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02084 i += skip;
02085 if(i > 31)
02086 break;
02087 idx = v->zz_4x8[i++]+off;
02088 block[idx] = value * scale;
02089 if(!v->pquantizer)
02090 block[idx] += (block[idx] < 0) ? -mquant : mquant;
02091 }
02092 if(!(subblkpat & (1 << (1 - j))) && !skip_block){
02093 if(i==1)
02094 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j*4, linesize, block + off);
02095 else
02096 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
02097 if(apply_filter && cbp_top & (2 << j))
02098 v->vc1dsp.vc1_v_loop_filter4(dst + j*4, linesize, v->pq);
02099 if(apply_filter && j ? pat & 0x5 : (cbp_left & 0xA))
02100 v->vc1dsp.vc1_h_loop_filter8(dst + j*4, linesize, v->pq);
02101 }
02102 }
02103 break;
02104 }
02105 return pat;
02106 }
02107
02109
02110 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
02111 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
02112
02115 static int vc1_decode_p_mb(VC1Context *v)
02116 {
02117 MpegEncContext *s = &v->s;
02118 GetBitContext *gb = &s->gb;
02119 int i;
02120 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02121 int cbp;
02122 int mqdiff, mquant;
02123 int ttmb = v->ttfrm;
02124
02125 int mb_has_coeffs = 1;
02126 int dmv_x, dmv_y;
02127 int index, index1;
02128 int val, sign;
02129 int first_block = 1;
02130 int dst_idx, off;
02131 int skipped, fourmv;
02132 int block_cbp = 0, pat;
02133 int apply_loop_filter;
02134
02135 mquant = v->pq;
02136
02137 if (v->mv_type_is_raw)
02138 fourmv = get_bits1(gb);
02139 else
02140 fourmv = v->mv_type_mb_plane[mb_pos];
02141 if (v->skip_is_raw)
02142 skipped = get_bits1(gb);
02143 else
02144 skipped = v->s.mbskip_table[mb_pos];
02145
02146 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
02147 if (!fourmv)
02148 {
02149 if (!skipped)
02150 {
02151 vc1_idct_func idct8x8_fn;
02152
02153 GET_MVDATA(dmv_x, dmv_y);
02154
02155 if (s->mb_intra) {
02156 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
02157 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
02158 }
02159 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
02160 vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
02161
02162
02163 if (s->mb_intra && !mb_has_coeffs)
02164 {
02165 GET_MQUANT();
02166 s->ac_pred = get_bits1(gb);
02167 cbp = 0;
02168 }
02169 else if (mb_has_coeffs)
02170 {
02171 if (s->mb_intra) s->ac_pred = get_bits1(gb);
02172 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02173 GET_MQUANT();
02174 }
02175 else
02176 {
02177 mquant = v->pq;
02178 cbp = 0;
02179 }
02180 s->current_picture.qscale_table[mb_pos] = mquant;
02181
02182 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
02183 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
02184 VC1_TTMB_VLC_BITS, 2);
02185 if(!s->mb_intra) vc1_mc_1mv(v, 0);
02186 dst_idx = 0;
02187 idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
02188 for (i=0; i<6; i++)
02189 {
02190 s->dc_val[0][s->block_index[i]] = 0;
02191 dst_idx += i >> 2;
02192 val = ((cbp >> (5 - i)) & 1);
02193 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
02194 v->mb_type[0][s->block_index[i]] = s->mb_intra;
02195 if(s->mb_intra) {
02196
02197 v->a_avail = v->c_avail = 0;
02198 if(i == 2 || i == 3 || !s->first_slice_line)
02199 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
02200 if(i == 1 || i == 3 || s->mb_x)
02201 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
02202
02203 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
02204 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
02205 idct8x8_fn(s->dest[dst_idx] + off,
02206 i & 4 ? s->uvlinesize : s->linesize,
02207 s->block[i]);
02208 if(v->pq >= 9 && v->overlap) {
02209 if(v->c_avail)
02210 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02211 if(v->a_avail)
02212 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02213 }
02214 if(apply_loop_filter && s->mb_x && s->mb_x != (s->mb_width - 1) && s->mb_y && s->mb_y != (s->mb_height - 1)){
02215 int left_cbp, top_cbp;
02216 if(i & 4){
02217 left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
02218 top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
02219 }else{
02220 left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
02221 top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
02222 }
02223 if(left_cbp & 0xC)
02224 v->vc1dsp.vc1_v_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02225 if(top_cbp & 0xA)
02226 v->vc1dsp.vc1_h_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02227 }
02228 block_cbp |= 0xF << (i << 2);
02229 } else if(val) {
02230 int left_cbp = 0, top_cbp = 0, filter = 0;
02231 if(apply_loop_filter && s->mb_x && s->mb_x != (s->mb_width - 1) && s->mb_y && s->mb_y != (s->mb_height - 1)){
02232 filter = 1;
02233 if(i & 4){
02234 left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
02235 top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
02236 }else{
02237 left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
02238 top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
02239 }
02240 if(left_cbp & 0xC)
02241 v->vc1dsp.vc1_v_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02242 if(top_cbp & 0xA)
02243 v->vc1dsp.vc1_h_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02244 }
02245 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);
02246 block_cbp |= pat << (i << 2);
02247 if(!v->ttmbf && ttmb < 8) ttmb = -1;
02248 first_block = 0;
02249 }
02250 }
02251 }
02252 else
02253 {
02254 s->mb_intra = 0;
02255 for(i = 0; i < 6; i++) {
02256 v->mb_type[0][s->block_index[i]] = 0;
02257 s->dc_val[0][s->block_index[i]] = 0;
02258 }
02259 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
02260 s->current_picture.qscale_table[mb_pos] = 0;
02261 vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
02262 vc1_mc_1mv(v, 0);
02263 return 0;
02264 }
02265 }
02266 else
02267 {
02268 if (!skipped )
02269 {
02270 int intra_count = 0, coded_inter = 0;
02271 int is_intra[6], is_coded[6];
02272 vc1_idct_func idct8x8_fn;
02273
02274 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02275 for (i=0; i<6; i++)
02276 {
02277 val = ((cbp >> (5 - i)) & 1);
02278 s->dc_val[0][s->block_index[i]] = 0;
02279 s->mb_intra = 0;
02280 if(i < 4) {
02281 dmv_x = dmv_y = 0;
02282 s->mb_intra = 0;
02283 mb_has_coeffs = 0;
02284 if(val) {
02285 GET_MVDATA(dmv_x, dmv_y);
02286 }
02287 vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
02288 if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
02289 intra_count += s->mb_intra;
02290 is_intra[i] = s->mb_intra;
02291 is_coded[i] = mb_has_coeffs;
02292 }
02293 if(i&4){
02294 is_intra[i] = (intra_count >= 3);
02295 is_coded[i] = val;
02296 }
02297 if(i == 4) vc1_mc_4mv_chroma(v);
02298 v->mb_type[0][s->block_index[i]] = is_intra[i];
02299 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
02300 }
02301
02302 if(!intra_count && !coded_inter) return 0;
02303 dst_idx = 0;
02304 GET_MQUANT();
02305 s->current_picture.qscale_table[mb_pos] = mquant;
02306
02307 {
02308 int intrapred = 0;
02309 for(i=0; i<6; i++)
02310 if(is_intra[i]) {
02311 if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
02312 || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
02313 intrapred = 1;
02314 break;
02315 }
02316 }
02317 if(intrapred)s->ac_pred = get_bits1(gb);
02318 else s->ac_pred = 0;
02319 }
02320 if (!v->ttmbf && coded_inter)
02321 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
02322 idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
02323 for (i=0; i<6; i++)
02324 {
02325 dst_idx += i >> 2;
02326 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
02327 s->mb_intra = is_intra[i];
02328 if (is_intra[i]) {
02329
02330 v->a_avail = v->c_avail = 0;
02331 if(i == 2 || i == 3 || !s->first_slice_line)
02332 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
02333 if(i == 1 || i == 3 || s->mb_x)
02334 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
02335
02336 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
02337 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
02338 idct8x8_fn(s->dest[dst_idx] + off,
02339 (i&4)?s->uvlinesize:s->linesize,
02340 s->block[i]);
02341 if(v->pq >= 9 && v->overlap) {
02342 if(v->c_avail)
02343 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02344 if(v->a_avail)
02345 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02346 }
02347 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)){
02348 int left_cbp, top_cbp;
02349 if(i & 4){
02350 left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
02351 top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
02352 }else{
02353 left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
02354 top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
02355 }
02356 if(left_cbp & 0xC)
02357 v->vc1dsp.vc1_v_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02358 if(top_cbp & 0xA)
02359 v->vc1dsp.vc1_h_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02360 }
02361 block_cbp |= 0xF << (i << 2);
02362 } else if(is_coded[i]) {
02363 int left_cbp = 0, top_cbp = 0, filter = 0;
02364 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)){
02365 filter = 1;
02366 if(i & 4){
02367 left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
02368 top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
02369 }else{
02370 left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
02371 top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
02372 }
02373 if(left_cbp & 0xC)
02374 v->vc1dsp.vc1_v_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02375 if(top_cbp & 0xA)
02376 v->vc1dsp.vc1_h_loop_filter8(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, v->pq);
02377 }
02378 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);
02379 block_cbp |= pat << (i << 2);
02380 if(!v->ttmbf && ttmb < 8) ttmb = -1;
02381 first_block = 0;
02382 }
02383 }
02384 return 0;
02385 }
02386 else
02387 {
02388 s->mb_intra = 0;
02389 s->current_picture.qscale_table[mb_pos] = 0;
02390 for (i=0; i<6; i++) {
02391 v->mb_type[0][s->block_index[i]] = 0;
02392 s->dc_val[0][s->block_index[i]] = 0;
02393 }
02394 for (i=0; i<4; i++)
02395 {
02396 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
02397 vc1_mc_4mv_luma(v, i);
02398 }
02399 vc1_mc_4mv_chroma(v);
02400 s->current_picture.qscale_table[mb_pos] = 0;
02401 return 0;
02402 }
02403 }
02404 v->cbp[s->mb_x] = block_cbp;
02405
02406
02407 return -1;
02408 }
02409
02412 static void vc1_decode_b_mb(VC1Context *v)
02413 {
02414 MpegEncContext *s = &v->s;
02415 GetBitContext *gb = &s->gb;
02416 int i;
02417 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02418 int cbp = 0;
02419 int mqdiff, mquant;
02420 int ttmb = v->ttfrm;
02421 int mb_has_coeffs = 0;
02422 int index, index1;
02423 int val, sign;
02424 int first_block = 1;
02425 int dst_idx, off;
02426 int skipped, direct;
02427 int dmv_x[2], dmv_y[2];
02428 int bmvtype = BMV_TYPE_BACKWARD;
02429 vc1_idct_func idct8x8_fn;
02430
02431 mquant = v->pq;
02432 s->mb_intra = 0;
02433
02434 if (v->dmb_is_raw)
02435 direct = get_bits1(gb);
02436 else
02437 direct = v->direct_mb_plane[mb_pos];
02438 if (v->skip_is_raw)
02439 skipped = get_bits1(gb);
02440 else
02441 skipped = v->s.mbskip_table[mb_pos];
02442
02443 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
02444 for(i = 0; i < 6; i++) {
02445 v->mb_type[0][s->block_index[i]] = 0;
02446 s->dc_val[0][s->block_index[i]] = 0;
02447 }
02448 s->current_picture.qscale_table[mb_pos] = 0;
02449
02450 if (!direct) {
02451 if (!skipped) {
02452 GET_MVDATA(dmv_x[0], dmv_y[0]);
02453 dmv_x[1] = dmv_x[0];
02454 dmv_y[1] = dmv_y[0];
02455 }
02456 if(skipped || !s->mb_intra) {
02457 bmvtype = decode012(gb);
02458 switch(bmvtype) {
02459 case 0:
02460 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
02461 break;
02462 case 1:
02463 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
02464 break;
02465 case 2:
02466 bmvtype = BMV_TYPE_INTERPOLATED;
02467 dmv_x[0] = dmv_y[0] = 0;
02468 }
02469 }
02470 }
02471 for(i = 0; i < 6; i++)
02472 v->mb_type[0][s->block_index[i]] = s->mb_intra;
02473
02474 if (skipped) {
02475 if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
02476 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02477 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02478 return;
02479 }
02480 if (direct) {
02481 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02482 GET_MQUANT();
02483 s->mb_intra = 0;
02484 s->current_picture.qscale_table[mb_pos] = mquant;
02485 if(!v->ttmbf)
02486 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
02487 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
02488 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02489 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02490 } else {
02491 if(!mb_has_coeffs && !s->mb_intra) {
02492
02493 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02494 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02495 return;
02496 }
02497 if(s->mb_intra && !mb_has_coeffs) {
02498 GET_MQUANT();
02499 s->current_picture.qscale_table[mb_pos] = mquant;
02500 s->ac_pred = get_bits1(gb);
02501 cbp = 0;
02502 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02503 } else {
02504 if(bmvtype == BMV_TYPE_INTERPOLATED) {
02505 GET_MVDATA(dmv_x[0], dmv_y[0]);
02506 if(!mb_has_coeffs) {
02507
02508 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02509 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02510 return;
02511 }
02512 }
02513 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02514 if(!s->mb_intra) {
02515 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02516 }
02517 if(s->mb_intra)
02518 s->ac_pred = get_bits1(gb);
02519 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02520 GET_MQUANT();
02521 s->current_picture.qscale_table[mb_pos] = mquant;
02522 if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
02523 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
02524 }
02525 }
02526 dst_idx = 0;
02527 idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
02528 for (i=0; i<6; i++)
02529 {
02530 s->dc_val[0][s->block_index[i]] = 0;
02531 dst_idx += i >> 2;
02532 val = ((cbp >> (5 - i)) & 1);
02533 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
02534 v->mb_type[0][s->block_index[i]] = s->mb_intra;
02535 if(s->mb_intra) {
02536
02537 v->a_avail = v->c_avail = 0;
02538 if(i == 2 || i == 3 || !s->first_slice_line)
02539 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
02540 if(i == 1 || i == 3 || s->mb_x)
02541 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
02542
02543 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
02544 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
02545 idct8x8_fn(s->dest[dst_idx] + off,
02546 i & 4 ? s->uvlinesize : s->linesize,
02547 s->block[i]);
02548 } else if(val) {
02549 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);
02550 if(!v->ttmbf && ttmb < 8) ttmb = -1;
02551 first_block = 0;
02552 }
02553 }
02554 }
02555
02558 static void vc1_decode_i_blocks(VC1Context *v)
02559 {
02560 int k;
02561 MpegEncContext *s = &v->s;
02562 int cbp, val;
02563 uint8_t *coded_val;
02564 int mb_pos;
02565 vc1_idct_func idct8x8_fn;
02566
02567
02568 switch(v->y_ac_table_index){
02569 case 0:
02570 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
02571 break;
02572 case 1:
02573 v->codingset = CS_HIGH_MOT_INTRA;
02574 break;
02575 case 2:
02576 v->codingset = CS_MID_RATE_INTRA;
02577 break;
02578 }
02579
02580 switch(v->c_ac_table_index){
02581 case 0:
02582 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
02583 break;
02584 case 1:
02585 v->codingset2 = CS_HIGH_MOT_INTER;
02586 break;
02587 case 2:
02588 v->codingset2 = CS_MID_RATE_INTER;
02589 break;
02590 }
02591
02592
02593 s->y_dc_scale = s->y_dc_scale_table[v->pq];
02594 s->c_dc_scale = s->c_dc_scale_table[v->pq];
02595
02596
02597 s->mb_x = s->mb_y = 0;
02598 s->mb_intra = 1;
02599 s->first_slice_line = 1;
02600 if(v->pq >= 9 && v->overlap) {
02601 idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
02602 } else
02603 idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put[!!v->rangeredfrm];
02604 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02605 s->mb_x = 0;
02606 ff_init_block_index(s);
02607 for(; s->mb_x < s->mb_width; s->mb_x++) {
02608 uint8_t *dst[6];
02609 ff_update_block_index(s);
02610 dst[0] = s->dest[0];
02611 dst[1] = dst[0] + 8;
02612 dst[2] = s->dest[0] + s->linesize * 8;
02613 dst[3] = dst[2] + 8;
02614 dst[4] = s->dest[1];
02615 dst[5] = s->dest[2];
02616 s->dsp.clear_blocks(s->block[0]);
02617 mb_pos = s->mb_x + s->mb_y * s->mb_width;
02618 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
02619 s->current_picture.qscale_table[mb_pos] = v->pq;
02620 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
02621 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
02622
02623
02624 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
02625 v->s.ac_pred = get_bits1(&v->s.gb);
02626
02627 for(k = 0; k < 6; k++) {
02628 val = ((cbp >> (5 - k)) & 1);
02629
02630 if (k < 4) {
02631 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
02632 val = val ^ pred;
02633 *coded_val = val;
02634 }
02635 cbp |= val << (5 - k);
02636
02637 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
02638
02639 if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue;
02640 idct8x8_fn(dst[k],
02641 k & 4 ? s->uvlinesize : s->linesize,
02642 s->block[k]);
02643 }
02644
02645 if(v->pq >= 9 && v->overlap) {
02646 if(s->mb_x) {
02647 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
02648 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
02649 if(!(s->flags & CODEC_FLAG_GRAY)) {
02650 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
02651 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
02652 }
02653 }
02654 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
02655 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
02656 if(!s->first_slice_line) {
02657 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
02658 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
02659 if(!(s->flags & CODEC_FLAG_GRAY)) {
02660 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
02661 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
02662 }
02663 }
02664 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
02665 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
02666 }
02667 if(v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
02668
02669 if(get_bits_count(&s->gb) > v->bits) {
02670 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
02671 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
02672 return;
02673 }
02674 }
02675 if (!v->s.loop_filter)
02676 ff_draw_horiz_band(s, s->mb_y * 16, 16);
02677 else if (s->mb_y)
02678 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
02679
02680 s->first_slice_line = 0;
02681 }
02682 if (v->s.loop_filter)
02683 ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
02684 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02685 }
02686
02689 static void vc1_decode_i_blocks_adv(VC1Context *v)
02690 {
02691 int k;
02692 MpegEncContext *s = &v->s;
02693 int cbp, val;
02694 uint8_t *coded_val;
02695 int mb_pos;
02696 int mquant = v->pq;
02697 int mqdiff;
02698 int overlap;
02699 GetBitContext *gb = &s->gb;
02700 vc1_idct_func idct8x8_fn;
02701
02702
02703 switch(v->y_ac_table_index){
02704 case 0:
02705 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
02706 break;
02707 case 1:
02708 v->codingset = CS_HIGH_MOT_INTRA;
02709 break;
02710 case 2:
02711 v->codingset = CS_MID_RATE_INTRA;
02712 break;
02713 }
02714
02715 switch(v->c_ac_table_index){
02716 case 0:
02717 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
02718 break;
02719 case 1:
02720 v->codingset2 = CS_HIGH_MOT_INTER;
02721 break;
02722 case 2:
02723 v->codingset2 = CS_MID_RATE_INTER;
02724 break;
02725 }
02726
02727
02728 s->mb_x = s->mb_y = 0;
02729 s->mb_intra = 1;
02730 s->first_slice_line = 1;
02731 idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[0];
02732 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02733 s->mb_x = 0;
02734 ff_init_block_index(s);
02735 for(;s->mb_x < s->mb_width; s->mb_x++) {
02736 uint8_t *dst[6];
02737 ff_update_block_index(s);
02738 dst[0] = s->dest[0];
02739 dst[1] = dst[0] + 8;
02740 dst[2] = s->dest[0] + s->linesize * 8;
02741 dst[3] = dst[2] + 8;
02742 dst[4] = s->dest[1];
02743 dst[5] = s->dest[2];
02744 s->dsp.clear_blocks(s->block[0]);
02745 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02746 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
02747 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
02748 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
02749
02750
02751 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
02752 if(v->acpred_is_raw)
02753 v->s.ac_pred = get_bits1(&v->s.gb);
02754 else
02755 v->s.ac_pred = v->acpred_plane[mb_pos];
02756
02757 if(v->condover == CONDOVER_SELECT) {
02758 if(v->overflg_is_raw)
02759 overlap = get_bits1(&v->s.gb);
02760 else
02761 overlap = v->over_flags_plane[mb_pos];
02762 } else
02763 overlap = (v->condover == CONDOVER_ALL);
02764
02765 GET_MQUANT();
02766
02767 s->current_picture.qscale_table[mb_pos] = mquant;
02768
02769 s->y_dc_scale = s->y_dc_scale_table[mquant];
02770 s->c_dc_scale = s->c_dc_scale_table[mquant];
02771
02772 for(k = 0; k < 6; k++) {
02773 val = ((cbp >> (5 - k)) & 1);
02774
02775 if (k < 4) {
02776 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
02777 val = val ^ pred;
02778 *coded_val = val;
02779 }
02780 cbp |= val << (5 - k);
02781
02782 v->a_avail = !s->first_slice_line || (k==2 || k==3);
02783 v->c_avail = !!s->mb_x || (k==1 || k==3);
02784
02785 vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
02786
02787 if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue;
02788 idct8x8_fn(dst[k],
02789 k & 4 ? s->uvlinesize : s->linesize,
02790 s->block[k]);
02791 }
02792
02793 if(overlap) {
02794 if(s->mb_x) {
02795 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
02796 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
02797 if(!(s->flags & CODEC_FLAG_GRAY)) {
02798 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
02799 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
02800 }
02801 }
02802 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
02803 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
02804 if(!s->first_slice_line) {
02805 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
02806 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
02807 if(!(s->flags & CODEC_FLAG_GRAY)) {
02808 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
02809 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
02810 }
02811 }
02812 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
02813 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
02814 }
02815 if(v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
02816
02817 if(get_bits_count(&s->gb) > v->bits) {
02818 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
02819 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
02820 return;
02821 }
02822 }
02823 if (!v->s.loop_filter)
02824 ff_draw_horiz_band(s, s->mb_y * 16, 16);
02825 else if (s->mb_y)
02826 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
02827 s->first_slice_line = 0;
02828 }
02829 if (v->s.loop_filter)
02830 ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
02831 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02832 }
02833
02834 static void vc1_decode_p_blocks(VC1Context *v)
02835 {
02836 MpegEncContext *s = &v->s;
02837
02838
02839 switch(v->c_ac_table_index){
02840 case 0:
02841 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
02842 break;
02843 case 1:
02844 v->codingset = CS_HIGH_MOT_INTRA;
02845 break;
02846 case 2:
02847 v->codingset = CS_MID_RATE_INTRA;
02848 break;
02849 }
02850
02851 switch(v->c_ac_table_index){
02852 case 0:
02853 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
02854 break;
02855 case 1:
02856 v->codingset2 = CS_HIGH_MOT_INTER;
02857 break;
02858 case 2:
02859 v->codingset2 = CS_MID_RATE_INTER;
02860 break;
02861 }
02862
02863 s->first_slice_line = 1;
02864 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
02865 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02866 s->mb_x = 0;
02867 ff_init_block_index(s);
02868 for(; s->mb_x < s->mb_width; s->mb_x++) {
02869 ff_update_block_index(s);
02870
02871 vc1_decode_p_mb(v);
02872 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
02873 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
02874 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);
02875 return;
02876 }
02877 }
02878 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0])*s->mb_stride);
02879 ff_draw_horiz_band(s, s->mb_y * 16, 16);
02880 s->first_slice_line = 0;
02881 }
02882 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02883 }
02884
02885 static void vc1_decode_b_blocks(VC1Context *v)
02886 {
02887 MpegEncContext *s = &v->s;
02888
02889
02890 switch(v->c_ac_table_index){
02891 case 0:
02892 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
02893 break;
02894 case 1:
02895 v->codingset = CS_HIGH_MOT_INTRA;
02896 break;
02897 case 2:
02898 v->codingset = CS_MID_RATE_INTRA;
02899 break;
02900 }
02901
02902 switch(v->c_ac_table_index){
02903 case 0:
02904 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
02905 break;
02906 case 1:
02907 v->codingset2 = CS_HIGH_MOT_INTER;
02908 break;
02909 case 2:
02910 v->codingset2 = CS_MID_RATE_INTER;
02911 break;
02912 }
02913
02914 s->first_slice_line = 1;
02915 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02916 s->mb_x = 0;
02917 ff_init_block_index(s);
02918 for(; s->mb_x < s->mb_width; s->mb_x++) {
02919 ff_update_block_index(s);
02920
02921 vc1_decode_b_mb(v);
02922 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
02923 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
02924 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);
02925 return;
02926 }
02927 if(v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
02928 }
02929 if (!v->s.loop_filter)
02930 ff_draw_horiz_band(s, s->mb_y * 16, 16);
02931 else if (s->mb_y)
02932 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
02933 s->first_slice_line = 0;
02934 }
02935 if (v->s.loop_filter)
02936 ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
02937 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02938 }
02939
02940 static void vc1_decode_skip_blocks(VC1Context *v)
02941 {
02942 MpegEncContext *s = &v->s;
02943
02944 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02945 s->first_slice_line = 1;
02946 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02947 s->mb_x = 0;
02948 ff_init_block_index(s);
02949 ff_update_block_index(s);
02950 memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
02951 memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
02952 memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
02953 ff_draw_horiz_band(s, s->mb_y * 16, 16);
02954 s->first_slice_line = 0;
02955 }
02956 s->pict_type = FF_P_TYPE;
02957 }
02958
02959 static void vc1_decode_blocks(VC1Context *v)
02960 {
02961
02962 v->s.esc3_level_length = 0;
02963 if(v->x8_type){
02964 ff_intrax8_decode_picture(&v->x8, 2*v->pq+v->halfpq, v->pq*(!v->pquantizer) );
02965 }else{
02966
02967 switch(v->s.pict_type) {
02968 case FF_I_TYPE:
02969 if(v->profile == PROFILE_ADVANCED)
02970 vc1_decode_i_blocks_adv(v);
02971 else
02972 vc1_decode_i_blocks(v);
02973 break;
02974 case FF_P_TYPE:
02975 if(v->p_frame_skipped)
02976 vc1_decode_skip_blocks(v);
02977 else
02978 vc1_decode_p_blocks(v);
02979 break;
02980 case FF_B_TYPE:
02981 if(v->bi_type){
02982 if(v->profile == PROFILE_ADVANCED)
02983 vc1_decode_i_blocks_adv(v);
02984 else
02985 vc1_decode_i_blocks(v);
02986 }else
02987 vc1_decode_b_blocks(v);
02988 break;
02989 }
02990 }
02991 }
02992
02997 static av_cold int vc1_decode_init(AVCodecContext *avctx)
02998 {
02999 VC1Context *v = avctx->priv_data;
03000 MpegEncContext *s = &v->s;
03001 GetBitContext gb;
03002 int i;
03003
03004 if (!avctx->extradata_size || !avctx->extradata) return -1;
03005 if (!(avctx->flags & CODEC_FLAG_GRAY))
03006 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
03007 else
03008 avctx->pix_fmt = PIX_FMT_GRAY8;
03009 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
03010 v->s.avctx = avctx;
03011 avctx->flags |= CODEC_FLAG_EMU_EDGE;
03012 v->s.flags |= CODEC_FLAG_EMU_EDGE;
03013
03014 if(avctx->idct_algo==FF_IDCT_AUTO){
03015 avctx->idct_algo=FF_IDCT_WMV2;
03016 }
03017
03018 if(ff_msmpeg4_decode_init(avctx) < 0)
03019 return -1;
03020 if (vc1_init_common(v) < 0) return -1;
03021 ff_vc1dsp_init(&v->vc1dsp);
03022 for (i = 0; i < 64; i++) {
03023 #define transpose(x) ((x>>3) | ((x&7)<<3))
03024 v->zz_8x8[0][i] = transpose(wmv1_scantable[0][i]);
03025 v->zz_8x8[1][i] = transpose(wmv1_scantable[1][i]);
03026 v->zz_8x8[2][i] = transpose(wmv1_scantable[2][i]);
03027 v->zz_8x8[3][i] = transpose(wmv1_scantable[3][i]);
03028 }
03029
03030 avctx->coded_width = avctx->width;
03031 avctx->coded_height = avctx->height;
03032 if (avctx->codec_id == CODEC_ID_WMV3)
03033 {
03034 int count = 0;
03035
03036
03037
03038
03039
03040
03041 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
03042
03043 if (vc1_decode_sequence_header(avctx, v, &gb) < 0)
03044 return -1;
03045
03046 count = avctx->extradata_size*8 - get_bits_count(&gb);
03047 if (count>0)
03048 {
03049 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
03050 count, get_bits(&gb, count));
03051 }
03052 else if (count < 0)
03053 {
03054 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
03055 }
03056 } else {
03057 const uint8_t *start = avctx->extradata;
03058 uint8_t *end = avctx->extradata + avctx->extradata_size;
03059 const uint8_t *next;
03060 int size, buf2_size;
03061 uint8_t *buf2 = NULL;
03062 int seq_initialized = 0, ep_initialized = 0;
03063
03064 if(avctx->extradata_size < 16) {
03065 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
03066 return -1;
03067 }
03068
03069 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
03070 start = find_next_marker(start, end);
03071 next = start;
03072 for(; next < end; start = next){
03073 next = find_next_marker(start + 4, end);
03074 size = next - start - 4;
03075 if(size <= 0) continue;
03076 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
03077 init_get_bits(&gb, buf2, buf2_size * 8);
03078 switch(AV_RB32(start)){
03079 case VC1_CODE_SEQHDR:
03080 if(vc1_decode_sequence_header(avctx, v, &gb) < 0){
03081 av_free(buf2);
03082 return -1;
03083 }
03084 seq_initialized = 1;
03085 break;
03086 case VC1_CODE_ENTRYPOINT:
03087 if(vc1_decode_entry_point(avctx, v, &gb) < 0){
03088 av_free(buf2);
03089 return -1;
03090 }
03091 ep_initialized = 1;
03092 break;
03093 }
03094 }
03095 av_free(buf2);
03096 if(!seq_initialized || !ep_initialized){
03097 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
03098 return -1;
03099 }
03100 }
03101 avctx->has_b_frames= !!(avctx->max_b_frames);
03102 s->low_delay = !avctx->has_b_frames;
03103
03104 s->mb_width = (avctx->coded_width+15)>>4;
03105 s->mb_height = (avctx->coded_height+15)>>4;
03106
03107
03108 v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
03109 v->direct_mb_plane = av_malloc(s->mb_stride * s->mb_height);
03110 v->acpred_plane = av_malloc(s->mb_stride * s->mb_height);
03111 v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height);
03112
03113 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
03114 v->cbp = v->cbp_base + s->mb_stride;
03115
03116
03117 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
03118 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
03119 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
03120 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
03121
03122
03123 if (v->profile == PROFILE_ADVANCED)
03124 {
03125
03126
03127
03128
03129 }
03130
03131 ff_intrax8_common_init(&v->x8,s);
03132 return 0;
03133 }
03134
03135
03139 static int vc1_decode_frame(AVCodecContext *avctx,
03140 void *data, int *data_size,
03141 AVPacket *avpkt)
03142 {
03143 const uint8_t *buf = avpkt->data;
03144 int buf_size = avpkt->size;
03145 VC1Context *v = avctx->priv_data;
03146 MpegEncContext *s = &v->s;
03147 AVFrame *pict = data;
03148 uint8_t *buf2 = NULL;
03149 const uint8_t *buf_start = buf;
03150
03151
03152 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
03153
03154 if (s->low_delay==0 && s->next_picture_ptr) {
03155 *pict= *(AVFrame*)s->next_picture_ptr;
03156 s->next_picture_ptr= NULL;
03157
03158 *data_size = sizeof(AVFrame);
03159 }
03160
03161 return 0;
03162 }
03163
03164
03165
03166 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
03167 int i= ff_find_unused_picture(s, 0);
03168 s->current_picture_ptr= &s->picture[i];
03169 }
03170
03171 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){
03172 if (v->profile < PROFILE_ADVANCED)
03173 avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
03174 else
03175 avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
03176 }
03177
03178
03179 if (avctx->codec_id == CODEC_ID_VC1) {
03180 int buf_size2 = 0;
03181 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
03182
03183 if(IS_MARKER(AV_RB32(buf))){
03184 const uint8_t *start, *end, *next;
03185 int size;
03186
03187 next = buf;
03188 for(start = buf, end = buf + buf_size; next < end; start = next){
03189 next = find_next_marker(start + 4, end);
03190 size = next - start - 4;
03191 if(size <= 0) continue;
03192 switch(AV_RB32(start)){
03193 case VC1_CODE_FRAME:
03194 if (avctx->hwaccel ||
03195 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
03196 buf_start = start;
03197 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
03198 break;
03199 case VC1_CODE_ENTRYPOINT:
03200 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
03201 init_get_bits(&s->gb, buf2, buf_size2*8);
03202 vc1_decode_entry_point(avctx, v, &s->gb);
03203 break;
03204 case VC1_CODE_SLICE:
03205 av_log(avctx, AV_LOG_ERROR, "Sliced decoding is not implemented (yet)\n");
03206 av_free(buf2);
03207 return -1;
03208 }
03209 }
03210 }else if(v->interlace && ((buf[0] & 0xC0) == 0xC0)){
03211 const uint8_t *divider;
03212
03213 divider = find_next_marker(buf, buf + buf_size);
03214 if((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD){
03215 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
03216 av_free(buf2);
03217 return -1;
03218 }
03219
03220 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
03221
03222 if(!v->warn_interlaced++)
03223 av_log(v->s.avctx, AV_LOG_ERROR, "Interlaced WVC1 support is not implemented\n");
03224 av_free(buf2);return -1;
03225 }else{
03226 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
03227 }
03228 init_get_bits(&s->gb, buf2, buf_size2*8);
03229 } else
03230 init_get_bits(&s->gb, buf, buf_size*8);
03231
03232 if(v->profile < PROFILE_ADVANCED) {
03233 if(vc1_parse_frame_header(v, &s->gb) == -1) {
03234 av_free(buf2);
03235 return -1;
03236 }
03237 } else {
03238 if(vc1_parse_frame_header_adv(v, &s->gb) == -1) {
03239 av_free(buf2);
03240 return -1;
03241 }
03242 }
03243
03244 if(v->res_sprite && (s->pict_type!=FF_I_TYPE)){
03245 av_free(buf2);
03246 return -1;
03247 }
03248
03249
03250 s->current_picture.pict_type= s->pict_type;
03251 s->current_picture.key_frame= s->pict_type == FF_I_TYPE;
03252
03253
03254 if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)){
03255 av_free(buf2);
03256 return -1;
03257 }
03258
03259 if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return -1;
03260 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
03261 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
03262 || avctx->skip_frame >= AVDISCARD_ALL) {
03263 av_free(buf2);
03264 return buf_size;
03265 }
03266
03267 if(avctx->hurry_up>=5) {
03268 av_free(buf2);
03269 return -1;
03270 }
03271
03272 if(s->next_p_frame_damaged){
03273 if(s->pict_type==FF_B_TYPE)
03274 return buf_size;
03275 else
03276 s->next_p_frame_damaged=0;
03277 }
03278
03279 if(MPV_frame_start(s, avctx) < 0) {
03280 av_free(buf2);
03281 return -1;
03282 }
03283
03284 s->me.qpel_put= s->dsp.put_qpel_pixels_tab;
03285 s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
03286
03287 if ((CONFIG_VC1_VDPAU_DECODER)
03288 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
03289 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
03290 else if (avctx->hwaccel) {
03291 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
03292 return -1;
03293 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
03294 return -1;
03295 if (avctx->hwaccel->end_frame(avctx) < 0)
03296 return -1;
03297 } else {
03298 ff_er_frame_start(s);
03299
03300 v->bits = buf_size * 8;
03301 vc1_decode_blocks(v);
03302
03303
03304
03305 ff_er_frame_end(s);
03306 }
03307
03308 MPV_frame_end(s);
03309
03310 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
03311 assert(s->current_picture.pict_type == s->pict_type);
03312 if (s->pict_type == FF_B_TYPE || s->low_delay) {
03313 *pict= *(AVFrame*)s->current_picture_ptr;
03314 } else if (s->last_picture_ptr != NULL) {
03315 *pict= *(AVFrame*)s->last_picture_ptr;
03316 }
03317
03318 if(s->last_picture_ptr || s->low_delay){
03319 *data_size = sizeof(AVFrame);
03320 ff_print_debug_info(s, pict);
03321 }
03322
03323 av_free(buf2);
03324 return buf_size;
03325 }
03326
03327
03331 static av_cold int vc1_decode_end(AVCodecContext *avctx)
03332 {
03333 VC1Context *v = avctx->priv_data;
03334
03335 av_freep(&v->hrd_rate);
03336 av_freep(&v->hrd_buffer);
03337 MPV_common_end(&v->s);
03338 av_freep(&v->mv_type_mb_plane);
03339 av_freep(&v->direct_mb_plane);
03340 av_freep(&v->acpred_plane);
03341 av_freep(&v->over_flags_plane);
03342 av_freep(&v->mb_type_base);
03343 av_freep(&v->cbp_base);
03344 ff_intrax8_common_end(&v->x8);
03345 return 0;
03346 }
03347
03348
03349 AVCodec ff_vc1_decoder = {
03350 "vc1",
03351 AVMEDIA_TYPE_VIDEO,
03352 CODEC_ID_VC1,
03353 sizeof(VC1Context),
03354 vc1_decode_init,
03355 NULL,
03356 vc1_decode_end,
03357 vc1_decode_frame,
03358 CODEC_CAP_DR1 | CODEC_CAP_DELAY,
03359 NULL,
03360 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
03361 .pix_fmts = ff_hwaccel_pixfmt_list_420
03362 };
03363
03364 #if CONFIG_WMV3_DECODER
03365 AVCodec ff_wmv3_decoder = {
03366 "wmv3",
03367 AVMEDIA_TYPE_VIDEO,
03368 CODEC_ID_WMV3,
03369 sizeof(VC1Context),
03370 vc1_decode_init,
03371 NULL,
03372 vc1_decode_end,
03373 vc1_decode_frame,
03374 CODEC_CAP_DR1 | CODEC_CAP_DELAY,
03375 NULL,
03376 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
03377 .pix_fmts = ff_hwaccel_pixfmt_list_420
03378 };
03379 #endif
03380
03381 #if CONFIG_WMV3_VDPAU_DECODER
03382 AVCodec ff_wmv3_vdpau_decoder = {
03383 "wmv3_vdpau",
03384 AVMEDIA_TYPE_VIDEO,
03385 CODEC_ID_WMV3,
03386 sizeof(VC1Context),
03387 vc1_decode_init,
03388 NULL,
03389 vc1_decode_end,
03390 vc1_decode_frame,
03391 CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
03392 NULL,
03393 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
03394 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE}
03395 };
03396 #endif
03397
03398 #if CONFIG_VC1_VDPAU_DECODER
03399 AVCodec ff_vc1_vdpau_decoder = {
03400 "vc1_vdpau",
03401 AVMEDIA_TYPE_VIDEO,
03402 CODEC_ID_VC1,
03403 sizeof(VC1Context),
03404 vc1_decode_init,
03405 NULL,
03406 vc1_decode_end,
03407 vc1_decode_frame,
03408 CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
03409 NULL,
03410 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
03411 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE}
03412 };
03413 #endif