Revision c47d3835 libavcodec/vc1dec.c
libavcodec/vc1dec.c  

209  209 
} 
210  210 
uvmx = (mx + ((mx & 3) == 3)) >> 1; 
211  211 
uvmy = (my + ((my & 3) == 3)) >> 1; 
212 
v>luma_mv[s>mb_x][0] = uvmx; 

213 
v>luma_mv[s>mb_x][1] = uvmy; 

212  214 
if(v>fastuvmc) { 
213  215 
uvmx = uvmx + ((uvmx<0)?(uvmx&1):(uvmx&1)); 
214  216 
uvmy = uvmy + ((uvmy<0)?(uvmy&1):(uvmy&1)); 
...  ...  
477  479 
} else { 
478  480 
s>current_picture.motion_val[1][s>block_index[0]][0] = 0; 
479  481 
s>current_picture.motion_val[1][s>block_index[0]][1] = 0; 
482 
v>luma_mv[s>mb_x][0] = v>luma_mv[s>mb_x][1] = 0; 

480  483 
return; //no need to do MC for inter blocks 
481  484 
} 
482  485  
...  ...  
484  487 
s>current_picture.motion_val[1][s>block_index[0]][1] = ty; 
485  488 
uvmx = (tx + ((tx&3) == 3)) >> 1; 
486  489 
uvmy = (ty + ((ty&3) == 3)) >> 1; 
490 
v>luma_mv[s>mb_x][0] = uvmx; 

491 
v>luma_mv[s>mb_x][1] = uvmy; 

487  492 
if(v>fastuvmc) { 
488  493 
uvmx = uvmx + ((uvmx<0)?(uvmx&1):(uvmx&1)); 
489  494 
uvmy = uvmy + ((uvmy<0)?(uvmy&1):(uvmy&1)); 
...  ...  
652  657  
653  658 
/** Predict and set motion vector 
654  659 
*/ 
655 
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)


660 
static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, int mv1, int r_x, int r_y, uint8_t* is_intra)


656  661 
{ 
662 
MpegEncContext *s = &v>s; 

657  663 
int xy, wrap, off = 0; 
658  664 
int16_t *A, *B, *C; 
659  665 
int px, py; 
...  ...  
678  684 
s>current_picture.motion_val[0][xy + wrap][1] = 0; 
679  685 
s>current_picture.motion_val[0][xy + wrap + 1][0] = 0; 
680  686 
s>current_picture.motion_val[0][xy + wrap + 1][1] = 0; 
687 
v>luma_mv[s>mb_x][0] = v>luma_mv[s>mb_x][1] = 0; 

681  688 
s>current_picture.motion_val[1][xy + 1][0] = 0; 
682  689 
s>current_picture.motion_val[1][xy + 1][1] = 0; 
683  690 
s>current_picture.motion_val[1][xy + wrap][0] = 0; 
...  ...  
1953  1960 
/** Decode P block 
1954  1961 
*/ 
1955  1962 
static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block, 
1956 
uint8_t *dst, int linesize, int skip_block, int apply_filter, int cbp_top, int cbp_left)


1963 
uint8_t *dst, int linesize, int skip_block, int *ttmb_out)


1957  1964 
{ 
1958  1965 
MpegEncContext *s = &v>s; 
1959  1966 
GetBitContext *gb = &s>gb; 
...  ...  
2011  2018 
else{ 
2012  2019 
v>vc1dsp.vc1_inv_trans_8x8_add(dst, linesize, block); 
2013  2020 
} 
2014 
if(apply_filter && cbp_top & 0xC) 

2015 
v>vc1dsp.vc1_v_loop_filter8(dst, linesize, v>pq); 

2016 
if(apply_filter && cbp_left & 0xA) 

2017 
v>vc1dsp.vc1_h_loop_filter8(dst, linesize, v>pq); 

2018  2021 
} 
2019  2022 
break; 
2020  2023 
case TT_4X4: 
...  ...  
2038  2041 
v>vc1dsp.vc1_inv_trans_4x4_dc(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off); 
2039  2042 
else 
2040  2043 
v>vc1dsp.vc1_inv_trans_4x4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off); 
2041 
if(apply_filter && (j&2 ? pat & (1<<(j2)) : (cbp_top & (1 << (j + 2))))) 

2042 
v>vc1dsp.vc1_v_loop_filter4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, v>pq); 

2043 
if(apply_filter && (j&1 ? pat & (1<<(j1)) : (cbp_left & (1 << (j + 1))))) 

2044 
v>vc1dsp.vc1_h_loop_filter4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, v>pq); 

2045  2044 
} 
2046  2045 
} 
2047  2046 
break; 
...  ...  
2066  2065 
v>vc1dsp.vc1_inv_trans_8x4_dc(dst + j*4*linesize, linesize, block + off); 
2067  2066 
else 
2068  2067 
v>vc1dsp.vc1_inv_trans_8x4(dst + j*4*linesize, linesize, block + off); 
2069 
if(apply_filter && j ? pat & 0x3 : (cbp_top & 0xC)) 

2070 
v>vc1dsp.vc1_v_loop_filter8(dst + j*4*linesize, linesize, v>pq); 

2071 
if(apply_filter && cbp_left & (2 << j)) 

2072 
v>vc1dsp.vc1_h_loop_filter4(dst + j*4*linesize, linesize, v>pq); 

2073  2068 
} 
2074  2069 
} 
2075  2070 
break; 
...  ...  
2094  2089 
v>vc1dsp.vc1_inv_trans_4x8_dc(dst + j*4, linesize, block + off); 
2095  2090 
else 
2096  2091 
v>vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off); 
2097 
if(apply_filter && cbp_top & (2 << j)) 

2098 
v>vc1dsp.vc1_v_loop_filter4(dst + j*4, linesize, v>pq); 

2099 
if(apply_filter && j ? pat & 0x5 : (cbp_left & 0xA)) 

2100 
v>vc1dsp.vc1_h_loop_filter8(dst + j*4, linesize, v>pq); 

2101  2092 
} 
2102  2093 
} 
2103  2094 
break; 
2104  2095 
} 
2096 
if (ttmb_out) 

2097 
*ttmb_out = ttblk << (n * 4); 

2105  2098 
return pat; 
2106  2099 
} 
2107  2100  
...  ...  
2110  2103 
static const int size_table [6] = { 0, 2, 3, 4, 5, 8 }; 
2111  2104 
static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 }; 
2112  2105  
2106 
static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num) 

2107 
{ 

2108 
MpegEncContext *s = &v>s; 

2109 
int mb_cbp = v>cbp[s>mb_x  s>mb_stride], 

2110 
block_cbp = mb_cbp >> (block_num * 4), bottom_cbp, 

2111 
mb_is_intra = v>is_intra[s>mb_x  s>mb_stride], 

2112 
block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra; 

2113 
int idx, linesize = block_num > 3 ? s>uvlinesize : s>linesize, ttblk; 

2114 
uint8_t *dst; 

2115  
2116 
if(block_num > 3) { 

2117 
dst = s>dest[block_num  3]; 

2118 
} else { 

2119 
dst = s>dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4  8) * linesize; 

2120 
} 

2121 
if (s>mb_y != s>mb_height  block_num < 2) { 

2122 
int16_t (*mv)[2]; 

2123 
int mv_stride; 

2124  
2125 
if(block_num > 3) { 

2126 
bottom_cbp = v>cbp[s>mb_x] >> (block_num * 4); 

2127 
bottom_is_intra = v>is_intra[s>mb_x] >> (block_num * 4); 

2128 
mv = &v>luma_mv[s>mb_x  s>mb_stride]; 

2129 
mv_stride = s>mb_stride; 

2130 
} else { 

2131 
bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4)) : 

2132 
(v>cbp[s>mb_x] >> ((block_num  2) * 4)); 

2133 
bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4)) : 

2134 
(v>is_intra[s>mb_x] >> ((block_num  2) * 4)); 

2135 
mv_stride = s>b8_stride; 

2136 
mv = &s>current_picture.motion_val[0][s>block_index[block_num]  2 * mv_stride]; 

2137 
} 

2138  
2139 
if (bottom_is_intra & 1  block_is_intra & 1  

2140 
mv[0][0] != mv[mv_stride][0]  mv[0][1] != mv[mv_stride][1]) { 

2141 
v>vc1dsp.vc1_v_loop_filter8(dst, linesize, v>pq); 

2142 
} else { 

2143 
idx = ((bottom_cbp >> 2)  block_cbp) & 3; 

2144 
if(idx == 3) { 

2145 
v>vc1dsp.vc1_v_loop_filter8(dst, linesize, v>pq); 

2146 
} else if (idx) { 

2147 
if (idx == 1) 

2148 
v>vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v>pq); 

2149 
else 

2150 
v>vc1dsp.vc1_v_loop_filter4(dst, linesize, v>pq); 

2151 
} 

2152 
} 

2153 
} 

2154  
2155 
dst = 4 * linesize; 

2156 
ttblk = (v>ttblk[s>mb_x  s>mb_stride] >> (block_num * 4)) & 0xf; 

2157 
if (ttblk == TT_4X4  ttblk == TT_8X4) { 

2158 
idx = (block_cbp  (block_cbp >> 2)) & 3; 

2159 
if (idx == 3) { 

2160 
v>vc1dsp.vc1_v_loop_filter8(dst, linesize, v>pq); 

2161 
} else if (idx) { 

2162 
if (idx == 1) 

2163 
v>vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v>pq); 

2164 
else 

2165 
v>vc1dsp.vc1_v_loop_filter4(dst, linesize, v>pq); 

2166 
} 

2167 
} 

2168 
} 

2169  
2170 
static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num) 

2171 
{ 

2172 
MpegEncContext *s = &v>s; 

2173 
int mb_cbp = v>cbp[s>mb_x  1  s>mb_stride], 

2174 
block_cbp = mb_cbp >> (block_num * 4), right_cbp, 

2175 
mb_is_intra = v>is_intra[s>mb_x  1  s>mb_stride], 

2176 
block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra; 

2177 
int idx, linesize = block_num > 3 ? s>uvlinesize : s>linesize, ttblk; 

2178 
uint8_t *dst; 

2179  
2180 
if (block_num > 3) { 

2181 
dst = s>dest[block_num  3]  8 * linesize; 

2182 
} else { 

2183 
dst = s>dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4  16) * linesize  8; 

2184 
} 

2185  
2186 
if (s>mb_x != s>mb_width  !(block_num & 5)) { 

2187 
int16_t (*mv)[2]; 

2188  
2189 
if(block_num > 3) { 

2190 
right_cbp = v>cbp[s>mb_x  s>mb_stride] >> (block_num * 4); 

2191 
right_is_intra = v>is_intra[s>mb_x  s>mb_stride] >> (block_num * 4); 

2192 
mv = &v>luma_mv[s>mb_x  s>mb_stride  1]; 

2193 
}else{ 

2194 
right_cbp = (block_num & 1) ? (v>cbp[s>mb_x  s>mb_stride] >> ((block_num  1) * 4)) : 

2195 
(mb_cbp >> ((block_num + 1) * 4)); 

2196 
right_is_intra = (block_num & 1) ? (v>is_intra[s>mb_x  s>mb_stride] >> ((block_num  1) * 4)) : 

2197 
(mb_is_intra >> ((block_num + 1) * 4)); 

2198 
mv = &s>current_picture.motion_val[0][s>block_index[block_num]  s>b8_stride * 2  2]; 

2199 
} 

2200 
if (block_is_intra & 1  right_is_intra & 1  mv[0][0] != mv[1][0]  mv[0][1] != mv[1][1]) { 

2201 
v>vc1dsp.vc1_h_loop_filter8(dst, linesize, v>pq); 

2202 
} else { 

2203 
idx = ((right_cbp >> 1)  block_cbp) & 5; // FIXME check 

2204 
if (idx == 5) { 

2205 
v>vc1dsp.vc1_h_loop_filter8(dst, linesize, v>pq); 

2206 
} else if (idx) { 

2207 
if (idx == 1) 

2208 
v>vc1dsp.vc1_h_loop_filter4(dst+4*linesize, linesize, v>pq); 

2209 
else 

2210 
v>vc1dsp.vc1_h_loop_filter4(dst, linesize, v>pq); 

2211 
} 

2212 
} 

2213 
} 

2214  
2215 
dst = 4; 

2216 
ttblk = (v>ttblk[s>mb_x  s>mb_stride  1] >> (block_num * 4)) & 0xf; 

2217 
if (ttblk == TT_4X4  ttblk == TT_4X8) { 

2218 
idx = (block_cbp  (block_cbp >> 1)) & 5; 

2219 
if (idx == 5) { 

2220 
v>vc1dsp.vc1_h_loop_filter8(dst, linesize, v>pq); 

2221 
} else if (idx) { 

2222 
if (idx == 1) 

2223 
v>vc1dsp.vc1_h_loop_filter4(dst + linesize*4, linesize, v>pq); 

2224 
else 

2225 
v>vc1dsp.vc1_h_loop_filter4(dst, linesize, v>pq); 

2226 
} 

2227 
} 

2228 
} 

2229  
2230 
static void vc1_apply_p_loop_filter(VC1Context *v) 

2231 
{ 

2232 
MpegEncContext *s = &v>s; 

2233 
int i; 

2234  
2235 
for (i = 0; i < 6; i++) { 

2236 
vc1_apply_p_v_loop_filter(v, i); 

2237 
} 

2238  
2239 
/* V always preceedes H, therefore we run H one MB before V; 

2240 
* at the end of a row, we catch up to complete the row */ 

2241 
if (s>mb_x) { 

2242 
for (i = 0; i < 6; i++) { 

2243 
vc1_apply_p_h_loop_filter(v, i); 

2244 
} 

2245 
if (s>mb_x == s>mb_width  1) { 

2246 
s>mb_x++; 

2247 
ff_update_block_index(s); 

2248 
for (i = 0; i < 6; i++) { 

2249 
vc1_apply_p_h_loop_filter(v, i); 

2250 
} 

2251 
} 

2252 
} 

2253 
} 

2254  
2113  2255 
/** Decode one Pframe MB (in Simple/Main profile) 
2114  2256 
*/ 
2115  2257 
static int vc1_decode_p_mb(VC1Context *v) 
...  ...  
2129  2271 
int first_block = 1; 
2130  2272 
int dst_idx, off; 
2131  2273 
int skipped, fourmv; 
2132 
int block_cbp = 0, pat; 

2133 
int apply_loop_filter; 

2274 
int block_cbp = 0, pat, block_tt = 0, block_intra = 0; 

2134  2275  
2135  2276 
mquant = v>pq; /* Loosy initialization */ 
2136  2277  
...  ...  
2143  2284 
else 
2144  2285 
skipped = v>s.mbskip_table[mb_pos]; 
2145  2286  
2146 
apply_loop_filter = s>loop_filter && !(s>avctx>skip_loop_filter >= AVDISCARD_NONKEY); 

2147  2287 
if (!fourmv) /* 1MV mode */ 
2148  2288 
{ 
2149  2289 
if (!skipped) 
...  ...  
2157  2297 
s>current_picture.motion_val[1][s>block_index[0]][1] = 0; 
2158  2298 
} 
2159  2299 
s>current_picture.mb_type[mb_pos] = s>mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16; 
2160 
vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v>range_x, v>range_y, v>mb_type[0]);


2300 
vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v>range_x, v>range_y, v>mb_type[0]);


2161  2301  
2162  2302 
/* FIXME Set DC val for inter block ? */ 
2163  2303 
if (s>mb_intra && !mb_has_coeffs) 
...  ...  
2211  2351 
if(v>a_avail) 
2212  2352 
v>vc1dsp.vc1_v_overlap(s>dest[dst_idx] + off, i & 4 ? s>uvlinesize : s>linesize); 
2213  2353 
} 
2214 
if(apply_loop_filter && s>mb_x && s>mb_x != (s>mb_width  1) && s>mb_y && s>mb_y != (s>mb_height  1)){ 

2215 
int left_cbp, top_cbp; 

2216 
if(i & 4){ 

2217 
left_cbp = v>cbp[s>mb_x  1] >> (i * 4); 

2218 
top_cbp = v>cbp[s>mb_x  s>mb_stride] >> (i * 4); 

2219 
}else{ 

2220 
left_cbp = (i & 1) ? (cbp >> ((i1)*4)) : (v>cbp[s>mb_x  1] >> ((i+1)*4)); 

2221 
top_cbp = (i & 2) ? (cbp >> ((i2)*4)) : (v>cbp[s>mb_x  s>mb_stride] >> ((i+2)*4)); 

2222 
} 

2223 
if(left_cbp & 0xC) 

2224 
v>vc1dsp.vc1_v_loop_filter8(s>dest[dst_idx] + off, i & 4 ? s>uvlinesize : s>linesize, v>pq); 

2225 
if(top_cbp & 0xA) 

2226 
v>vc1dsp.vc1_h_loop_filter8(s>dest[dst_idx] + off, i & 4 ? s>uvlinesize : s>linesize, v>pq); 

2227 
} 

2228  2354 
block_cbp = 0xF << (i << 2); 
2355 
block_intra = 1 << i; 

2229  2356 
} else if(val) { 
2230 
int left_cbp = 0, top_cbp = 0, filter = 0; 

2231 
if(apply_loop_filter && s>mb_x && s>mb_x != (s>mb_width  1) && s>mb_y && s>mb_y != (s>mb_height  1)){ 

2232 
filter = 1; 

2233 
if(i & 4){ 

2234 
left_cbp = v>cbp[s>mb_x  1] >> (i * 4); 

2235 
top_cbp = v>cbp[s>mb_x  s>mb_stride] >> (i * 4); 

2236 
}else{ 

2237 
left_cbp = (i & 1) ? (cbp >> ((i1)*4)) : (v>cbp[s>mb_x  1] >> ((i+1)*4)); 

2238 
top_cbp = (i & 2) ? (cbp >> ((i2)*4)) : (v>cbp[s>mb_x  s>mb_stride] >> ((i+2)*4)); 

2239 
} 

2240 
if(left_cbp & 0xC) 

2241 
v>vc1dsp.vc1_v_loop_filter8(s>dest[dst_idx] + off, i & 4 ? s>uvlinesize : s>linesize, v>pq); 

2242 
if(top_cbp & 0xA) 

2243 
v>vc1dsp.vc1_h_loop_filter8(s>dest[dst_idx] + off, i & 4 ? s>uvlinesize : s>linesize, v>pq); 

2244 
} 

2245 
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); 

2357 
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), &block_tt); 

2246  2358 
block_cbp = pat << (i << 2); 
2247  2359 
if(!v>ttmbf && ttmb < 8) ttmb = 1; 
2248  2360 
first_block = 0; 
...  ...  
2258  2370 
} 
2259  2371 
s>current_picture.mb_type[mb_pos] = MB_TYPE_SKIP; 
2260  2372 
s>current_picture.qscale_table[mb_pos] = 0; 
2261 
vc1_pred_mv(s, 0, 0, 0, 1, v>range_x, v>range_y, v>mb_type[0]);


2373 
vc1_pred_mv(v, 0, 0, 0, 1, v>range_x, v>range_y, v>mb_type[0]);


2262  2374 
vc1_mc_1mv(v, 0); 
2263 
return 0; 

2264  2375 
} 
2265  2376 
} //1MV mode 
2266  2377 
else //4MV mode 
...  ...  
2284  2395 
if(val) { 
2285  2396 
GET_MVDATA(dmv_x, dmv_y); 
2286  2397 
} 
2287 
vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v>range_x, v>range_y, v>mb_type[0]);


2398 
vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v>range_x, v>range_y, v>mb_type[0]);


2288  2399 
if(!s>mb_intra) vc1_mc_4mv_luma(v, i); 
2289  2400 
intra_count += s>mb_intra; 
2290  2401 
is_intra[i] = s>mb_intra; 
...  ...  
2299  2410 
if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i]; 
2300  2411 
} 
2301  2412 
// if there are no coded blocks then don't do anything more 
2302 
if(!intra_count && !coded_inter) return 0; 

2303  2413 
dst_idx = 0; 
2414 
if(!intra_count && !coded_inter) 

2415 
goto end; 

2304  2416 
GET_MQUANT(); 
2305  2417 
s>current_picture.qscale_table[mb_pos] = mquant; 
2306  2418 
/* test if block is intra and has pred */ 
...  ...  
2344  2456 
if(v>a_avail) 
2345  2457 
v>vc1dsp.vc1_v_overlap(s>dest[dst_idx] + off, i & 4 ? s>uvlinesize : s>linesize); 
2346  2458 
} 
2347 
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)){ 

2348 
int left_cbp, top_cbp; 

2349 
if(i & 4){ 

2350 
left_cbp = v>cbp[s>mb_x  1] >> (i * 4); 

2351 
top_cbp = v>cbp[s>mb_x  s>mb_stride] >> (i * 4); 

2352 
}else{ 

2353 
left_cbp = (i & 1) ? (cbp >> ((i1)*4)) : (v>cbp[s>mb_x  1] >> ((i+1)*4)); 

2354 
top_cbp = (i & 2) ? (cbp >> ((i2)*4)) : (v>cbp[s>mb_x  s>mb_stride] >> ((i+2)*4)); 

2355 
} 

2356 
if(left_cbp & 0xC) 

2357 
v>vc1dsp.vc1_v_loop_filter8(s>dest[dst_idx] + off, i & 4 ? s>uvlinesize : s>linesize, v>pq); 

2358 
if(top_cbp & 0xA) 

2359 
v>vc1dsp.vc1_h_loop_filter8(s>dest[dst_idx] + off, i & 4 ? s>uvlinesize : s>linesize, v>pq); 

2360 
} 

2361  2459 
block_cbp = 0xF << (i << 2); 
2460 
block_intra = 1 << i; 

2362  2461 
} else if(is_coded[i]) { 
2363 
int left_cbp = 0, top_cbp = 0, filter = 0; 

2364 
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)){ 

2365 
filter = 1; 

2366 
if(i & 4){ 

2367 
left_cbp = v>cbp[s>mb_x  1] >> (i * 4); 

2368 
top_cbp = v>cbp[s>mb_x  s>mb_stride] >> (i * 4); 

2369 
}else{ 

2370 
left_cbp = (i & 1) ? (cbp >> ((i1)*4)) : (v>cbp[s>mb_x  1] >> ((i+1)*4)); 

2371 
top_cbp = (i & 2) ? (cbp >> ((i2)*4)) : (v>cbp[s>mb_x  s>mb_stride] >> ((i+2)*4)); 

2372 
} 

2373 
if(left_cbp & 0xC) 

2374 
v>vc1dsp.vc1_v_loop_filter8(s>dest[dst_idx] + off, i & 4 ? s>uvlinesize : s>linesize, v>pq); 

2375 
if(top_cbp & 0xA) 

2376 
v>vc1dsp.vc1_h_loop_filter8(s>dest[dst_idx] + off, i & 4 ? s>uvlinesize : s>linesize, v>pq); 

2377 
} 

2378 
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); 

2462 
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), &block_tt); 

2379  2463 
block_cbp = pat << (i << 2); 
2380  2464 
if(!v>ttmbf && ttmb < 8) ttmb = 1; 
2381  2465 
first_block = 0; 
2382  2466 
} 
2383  2467 
} 
2384 
return 0; 

2385  2468 
} 
2386  2469 
else //Skipped MB 
2387  2470 
{ 
...  ...  
2393  2476 
} 
2394  2477 
for (i=0; i<4; i++) 
2395  2478 
{ 
2396 
vc1_pred_mv(s, i, 0, 0, 0, v>range_x, v>range_y, v>mb_type[0]);


2479 
vc1_pred_mv(v, i, 0, 0, 0, v>range_x, v>range_y, v>mb_type[0]);


2397  2480 
vc1_mc_4mv_luma(v, i); 
2398  2481 
} 
2399  2482 
vc1_mc_4mv_chroma(v); 
2400  2483 
s>current_picture.qscale_table[mb_pos] = 0; 
2401 
return 0; 

2402  2484 
} 
2403  2485 
} 
2486 
end: 

2404  2487 
v>cbp[s>mb_x] = block_cbp; 
2488 
v>ttblk[s>mb_x] = block_tt; 

2489 
v>is_intra[s>mb_x] = block_intra; 

2405  2490  
2406 
/* Should never happen */ 

2407 
return 1; 

2491 
return 0; 

2408  2492 
} 
2409  2493  
2410  2494 
/** Decode one Bframe MB (in Main profile) 
...  ...  
2546  2630 
i & 4 ? s>uvlinesize : s>linesize, 
2547  2631 
s>block[i]); 
2548  2632 
} else if(val) { 
2549 
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);


2633 
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), NULL);


2550  2634 
if(!v>ttmbf && ttmb < 8) ttmb = 1; 
2551  2635 
first_block = 0; 
2552  2636 
} 
...  ...  
2841  2925 
static void vc1_decode_p_blocks(VC1Context *v, int mby_start, int mby_end) 
2842  2926 
{ 
2843  2927 
MpegEncContext *s = &v>s; 
2928 
int apply_loop_filter; 

2844  2929  
2845  2930 
/* select codingmode used for VLC tables selection */ 
2846  2931 
switch(v>c_ac_table_index){ 
...  ...  
2867  2952 
break; 
2868  2953 
} 
2869  2954  
2955 
apply_loop_filter = s>loop_filter && !(s>avctx>skip_loop_filter >= AVDISCARD_NONKEY); 

2870  2956 
s>first_slice_line = 1; 
2871  2957 
memset(v>cbp_base, 0, sizeof(v>cbp_base[0])*2*s>mb_stride); 
2872  2958 
for(s>mb_y = mby_start; s>mb_y < mby_end; s>mb_y++) { 
...  ...  
2876  2962 
ff_update_block_index(s); 
2877  2963  
2878  2964 
vc1_decode_p_mb(v); 
2965 
if (s>mb_y != mby_start && apply_loop_filter) 

2966 
vc1_apply_p_loop_filter(v); 

2879  2967 
if(get_bits_count(&s>gb) > v>bits  get_bits_count(&s>gb) < 0) { 
2880  2968 
ff_er_add_slice(s, 0, mby_start, s>mb_x, s>mb_y, (AC_ENDDC_ENDMV_END)); 
2881  2969 
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); 
...  ...  
2883  2971 
} 
2884  2972 
} 
2885  2973 
memmove(v>cbp_base, v>cbp, sizeof(v>cbp_base[0])*s>mb_stride); 
2886 
ff_draw_horiz_band(s, s>mb_y * 16, 16); 

2974 
memmove(v>ttblk_base, v>ttblk, sizeof(v>ttblk_base[0])*s>mb_stride); 

2975 
memmove(v>is_intra_base, v>is_intra, sizeof(v>is_intra_base[0])*s>mb_stride); 

2976 
memmove(v>luma_mv_base, v>luma_mv, sizeof(v>luma_mv_base[0])*s>mb_stride); 

2977 
if (s>mb_y != mby_start) ff_draw_horiz_band(s, (s>mb_y1) * 16, 16); 

2887  2978 
s>first_slice_line = 0; 
2888  2979 
} 
2980 
if (apply_loop_filter) { 

2981 
s>mb_x = 0; 

2982 
ff_init_block_index(s); 

2983 
for (; s>mb_x < s>mb_width; s>mb_x++) { 

2984 
ff_update_block_index(s); 

2985 
vc1_apply_p_loop_filter(v); 

2986 
} 

2987 
} 

2988 
if (mby_end >= mby_start) 

2989 
ff_draw_horiz_band(s, (mby_end1) * 16, 16); 

2889  2990 
ff_er_add_slice(s, 0, mby_start, s>mb_width  1, mby_end  1, (AC_ENDDC_ENDMV_END)); 
2890  2991 
} 
2891  2992  
...  ...  
3122  3223  
3123  3224 
v>cbp_base = av_malloc(sizeof(v>cbp_base[0]) * 2 * s>mb_stride); 
3124  3225 
v>cbp = v>cbp_base + s>mb_stride; 
3226 
v>ttblk_base = av_malloc(sizeof(v>ttblk_base[0]) * 2 * s>mb_stride); 

3227 
v>ttblk = v>ttblk_base + s>mb_stride; 

3228 
v>is_intra_base = av_malloc(sizeof(v>is_intra_base[0]) * 2 * s>mb_stride); 

3229 
v>is_intra = v>is_intra_base + s>mb_stride; 

3230 
v>luma_mv_base = av_malloc(sizeof(v>luma_mv_base[0]) * 2 * s>mb_stride); 

3231 
v>luma_mv = v>luma_mv_base + s>mb_stride; 

3125  3232  
3126  3233 
/* allocate block type info in that way so it could be used with s>block_index[] */ 
3127  3234 
v>mb_type_base = av_malloc(s>b8_stride * (s>mb_height * 2 + 1) + s>mb_stride * (s>mb_height + 1) * 2); 
...  ...  
3375  3482 
av_freep(&v>over_flags_plane); 
3376  3483 
av_freep(&v>mb_type_base); 
3377  3484 
av_freep(&v>cbp_base); 
3485 
av_freep(&v>ttblk_base); 

3486 
av_freep(&v>is_intra_base); // FIXME use v>mb_type[] 

3487 
av_freep(&v>luma_mv_base); 

3378  3488 
ff_intrax8_common_end(&v>x8); 
3379  3489 
return 0; 
3380  3490 
} 
Also available in: Unified diff