00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00029 #include "internal.h"
00030 #include "dsputil.h"
00031 #include "avcodec.h"
00032 #include "mpegvideo.h"
00033 #include "h263.h"
00034 #include "vc1.h"
00035 #include "vc1data.h"
00036 #include "vc1acdata.h"
00037 #include "msmpeg4data.h"
00038 #include "unary.h"
00039 #include "simple_idct.h"
00040 #include "mathops.h"
00041 #include "vdpau_internal.h"
00042
00043 #undef NDEBUG
00044 #include <assert.h>
00045
00046 #define MB_INTRA_VLC_BITS 9
00047 #define DC_VLC_BITS 9
00048 #define AC_VLC_BITS 9
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, 8342,
00054 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
00055 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
00056 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
00057 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
00058 31714, 31746, 31778, 32306, 32340, 32372
00059 };
00060
00061
00062 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
00063 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
00064
00070 int ff_vc1_init_common(VC1Context *v)
00071 {
00072 static int done = 0;
00073 int i = 0;
00074 static VLC_TYPE vlc_table[32372][2];
00075
00076 v->hrd_rate = v->hrd_buffer = NULL;
00077
00078
00079 if (!done) {
00080 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
00081 ff_vc1_bfraction_bits, 1, 1,
00082 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
00083 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
00084 ff_vc1_norm2_bits, 1, 1,
00085 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
00086 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
00087 ff_vc1_norm6_bits, 1, 1,
00088 ff_vc1_norm6_codes, 2, 2, 556);
00089 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
00090 ff_vc1_imode_bits, 1, 1,
00091 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
00092 for (i = 0; i < 3; i++) {
00093 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
00094 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
00095 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
00096 ff_vc1_ttmb_bits[i], 1, 1,
00097 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00098 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
00099 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
00100 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
00101 ff_vc1_ttblk_bits[i], 1, 1,
00102 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00103 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
00104 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
00105 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
00106 ff_vc1_subblkpat_bits[i], 1, 1,
00107 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00108 }
00109 for (i = 0; i < 4; i++) {
00110 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
00111 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
00112 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
00113 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
00114 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00115 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
00116 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
00117 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
00118 ff_vc1_cbpcy_p_bits[i], 1, 1,
00119 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00120 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
00121 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
00122 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
00123 ff_vc1_mv_diff_bits[i], 1, 1,
00124 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00125 }
00126 for (i = 0; i < 8; i++) {
00127 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
00128 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
00129 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
00130 &vc1_ac_tables[i][0][1], 8, 4,
00131 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
00132
00133 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
00134 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
00135 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
00136 ff_vc1_2ref_mvdata_bits[i], 1, 1,
00137 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
00138 }
00139 for (i = 0; i < 4; i++) {
00140
00141 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
00142 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
00143 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
00144 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
00145 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00146
00147 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
00148 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
00149 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
00150 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
00151 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00152
00153 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
00154 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
00155 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
00156 ff_vc1_1ref_mvdata_bits[i], 1, 1,
00157 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
00158 }
00159 for (i = 0; i < 4; i++) {
00160
00161 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
00162 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
00163 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
00164 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
00165 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00166 }
00167 for (i = 0; i < 8; i++) {
00168
00169 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
00170 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
00171 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
00172 ff_vc1_icbpcy_p_bits[i], 1, 1,
00173 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00174
00175 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
00176 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
00177 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
00178 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
00179 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00180 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
00181 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
00182 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
00183 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
00184 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00185 }
00186 done = 1;
00187 }
00188
00189
00190 v->pq = -1;
00191 v->mvrange = 0;
00192
00193 return 0;
00194 }
00195
00196
00207 enum Imode {
00208 IMODE_RAW,
00209 IMODE_NORM2,
00210 IMODE_DIFF2,
00211 IMODE_NORM6,
00212 IMODE_DIFF6,
00213 IMODE_ROWSKIP,
00214 IMODE_COLSKIP
00215 };
00217
00218
00220
00221 static void vc1_put_signed_blocks_clamped(VC1Context *v)
00222 {
00223 MpegEncContext *s = &v->s;
00224 int topleft_mb_pos, top_mb_pos;
00225 int stride_y, fieldtx;
00226 int v_dist;
00227
00228
00229
00230
00231
00232
00233
00234
00235 if (!s->first_slice_line) {
00236 if (s->mb_x) {
00237 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
00238 fieldtx = v->fieldtx_plane[topleft_mb_pos];
00239 stride_y = s->linesize << fieldtx;
00240 v_dist = (16 - fieldtx) >> (fieldtx == 0);
00241 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
00242 s->dest[0] - 16 * s->linesize - 16,
00243 stride_y);
00244 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
00245 s->dest[0] - 16 * s->linesize - 8,
00246 stride_y);
00247 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
00248 s->dest[0] - v_dist * s->linesize - 16,
00249 stride_y);
00250 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
00251 s->dest[0] - v_dist * s->linesize - 8,
00252 stride_y);
00253 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
00254 s->dest[1] - 8 * s->uvlinesize - 8,
00255 s->uvlinesize);
00256 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
00257 s->dest[2] - 8 * s->uvlinesize - 8,
00258 s->uvlinesize);
00259 }
00260 if (s->mb_x == s->mb_width - 1) {
00261 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
00262 fieldtx = v->fieldtx_plane[top_mb_pos];
00263 stride_y = s->linesize << fieldtx;
00264 v_dist = fieldtx ? 15 : 8;
00265 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
00266 s->dest[0] - 16 * s->linesize,
00267 stride_y);
00268 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
00269 s->dest[0] - 16 * s->linesize + 8,
00270 stride_y);
00271 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
00272 s->dest[0] - v_dist * s->linesize,
00273 stride_y);
00274 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
00275 s->dest[0] - v_dist * s->linesize + 8,
00276 stride_y);
00277 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
00278 s->dest[1] - 8 * s->uvlinesize,
00279 s->uvlinesize);
00280 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
00281 s->dest[2] - 8 * s->uvlinesize,
00282 s->uvlinesize);
00283 }
00284 }
00285
00286 #define inc_blk_idx(idx) do { \
00287 idx++; \
00288 if (idx >= v->n_allocated_blks) \
00289 idx = 0; \
00290 } while (0)
00291
00292 inc_blk_idx(v->topleft_blk_idx);
00293 inc_blk_idx(v->top_blk_idx);
00294 inc_blk_idx(v->left_blk_idx);
00295 inc_blk_idx(v->cur_blk_idx);
00296 }
00297
00298 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
00299 {
00300 MpegEncContext *s = &v->s;
00301 int j;
00302 if (!s->first_slice_line) {
00303 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
00304 if (s->mb_x)
00305 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
00306 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
00307 for (j = 0; j < 2; j++) {
00308 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
00309 if (s->mb_x)
00310 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
00311 }
00312 }
00313 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
00314
00315 if (s->mb_y == s->end_mb_y - 1) {
00316 if (s->mb_x) {
00317 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
00318 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
00319 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
00320 }
00321 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
00322 }
00323 }
00324
00325 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
00326 {
00327 MpegEncContext *s = &v->s;
00328 int j;
00329
00330
00331
00332 if (!s->first_slice_line) {
00333 if (s->mb_x) {
00334 if (s->mb_y >= s->start_mb_y + 2) {
00335 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
00336
00337 if (s->mb_x >= 2)
00338 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
00339 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
00340 for (j = 0; j < 2; j++) {
00341 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
00342 if (s->mb_x >= 2) {
00343 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
00344 }
00345 }
00346 }
00347 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
00348 }
00349
00350 if (s->mb_x == s->mb_width - 1) {
00351 if (s->mb_y >= s->start_mb_y + 2) {
00352 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
00353
00354 if (s->mb_x)
00355 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
00356 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
00357 for (j = 0; j < 2; j++) {
00358 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
00359 if (s->mb_x >= 2) {
00360 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
00361 }
00362 }
00363 }
00364 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
00365 }
00366
00367 if (s->mb_y == s->end_mb_y) {
00368 if (s->mb_x) {
00369 if (s->mb_x >= 2)
00370 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
00371 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
00372 if (s->mb_x >= 2) {
00373 for (j = 0; j < 2; j++) {
00374 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
00375 }
00376 }
00377 }
00378
00379 if (s->mb_x == s->mb_width - 1) {
00380 if (s->mb_x)
00381 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
00382 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
00383 if (s->mb_x) {
00384 for (j = 0; j < 2; j++) {
00385 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
00386 }
00387 }
00388 }
00389 }
00390 }
00391 }
00392
00393 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
00394 {
00395 MpegEncContext *s = &v->s;
00396 int mb_pos;
00397
00398 if (v->condover == CONDOVER_NONE)
00399 return;
00400
00401 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
00402
00403
00404
00405
00406
00407
00408
00409
00410 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
00411 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
00412 v->over_flags_plane[mb_pos - 1])) {
00413 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
00414 v->block[v->cur_blk_idx][0]);
00415 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
00416 v->block[v->cur_blk_idx][2]);
00417 if (!(s->flags & CODEC_FLAG_GRAY)) {
00418 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
00419 v->block[v->cur_blk_idx][4]);
00420 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
00421 v->block[v->cur_blk_idx][5]);
00422 }
00423 }
00424 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
00425 v->block[v->cur_blk_idx][1]);
00426 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
00427 v->block[v->cur_blk_idx][3]);
00428
00429 if (s->mb_x == s->mb_width - 1) {
00430 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
00431 v->over_flags_plane[mb_pos - s->mb_stride])) {
00432 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
00433 v->block[v->cur_blk_idx][0]);
00434 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
00435 v->block[v->cur_blk_idx][1]);
00436 if (!(s->flags & CODEC_FLAG_GRAY)) {
00437 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
00438 v->block[v->cur_blk_idx][4]);
00439 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
00440 v->block[v->cur_blk_idx][5]);
00441 }
00442 }
00443 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
00444 v->block[v->cur_blk_idx][2]);
00445 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
00446 v->block[v->cur_blk_idx][3]);
00447 }
00448 }
00449 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
00450 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
00451 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
00452 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
00453 v->block[v->left_blk_idx][0]);
00454 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
00455 v->block[v->left_blk_idx][1]);
00456 if (!(s->flags & CODEC_FLAG_GRAY)) {
00457 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
00458 v->block[v->left_blk_idx][4]);
00459 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
00460 v->block[v->left_blk_idx][5]);
00461 }
00462 }
00463 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
00464 v->block[v->left_blk_idx][2]);
00465 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
00466 v->block[v->left_blk_idx][3]);
00467 }
00468 }
00469
00473 static void vc1_mc_1mv(VC1Context *v, int dir)
00474 {
00475 MpegEncContext *s = &v->s;
00476 DSPContext *dsp = &v->s.dsp;
00477 uint8_t *srcY, *srcU, *srcV;
00478 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
00479 int off, off_uv;
00480 int v_edge_pos = s->v_edge_pos >> v->field_mode;
00481
00482 if ((!v->field_mode ||
00483 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
00484 !v->s.last_picture.f.data[0])
00485 return;
00486
00487 mx = s->mv[dir][0][0];
00488 my = s->mv[dir][0][1];
00489
00490
00491 if (s->pict_type == AV_PICTURE_TYPE_P) {
00492 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
00493 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
00494 }
00495
00496 uvmx = (mx + ((mx & 3) == 3)) >> 1;
00497 uvmy = (my + ((my & 3) == 3)) >> 1;
00498 v->luma_mv[s->mb_x][0] = uvmx;
00499 v->luma_mv[s->mb_x][1] = uvmy;
00500
00501 if (v->field_mode &&
00502 v->cur_field_type != v->ref_field_type[dir]) {
00503 my = my - 2 + 4 * v->cur_field_type;
00504 uvmy = uvmy - 2 + 4 * v->cur_field_type;
00505 }
00506
00507
00508 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
00509 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
00510 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
00511 }
00512 if (v->field_mode) {
00513 if (!dir) {
00514 if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type) {
00515 srcY = s->current_picture.f.data[0];
00516 srcU = s->current_picture.f.data[1];
00517 srcV = s->current_picture.f.data[2];
00518 } else {
00519 srcY = s->last_picture.f.data[0];
00520 srcU = s->last_picture.f.data[1];
00521 srcV = s->last_picture.f.data[2];
00522 }
00523 } else {
00524 srcY = s->next_picture.f.data[0];
00525 srcU = s->next_picture.f.data[1];
00526 srcV = s->next_picture.f.data[2];
00527 }
00528 } else {
00529 if (!dir) {
00530 srcY = s->last_picture.f.data[0];
00531 srcU = s->last_picture.f.data[1];
00532 srcV = s->last_picture.f.data[2];
00533 } else {
00534 srcY = s->next_picture.f.data[0];
00535 srcU = s->next_picture.f.data[1];
00536 srcV = s->next_picture.f.data[2];
00537 }
00538 }
00539
00540 src_x = s->mb_x * 16 + (mx >> 2);
00541 src_y = s->mb_y * 16 + (my >> 2);
00542 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00543 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00544
00545 if (v->profile != PROFILE_ADVANCED) {
00546 src_x = av_clip( src_x, -16, s->mb_width * 16);
00547 src_y = av_clip( src_y, -16, s->mb_height * 16);
00548 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
00549 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00550 } else {
00551 src_x = av_clip( src_x, -17, s->avctx->coded_width);
00552 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
00553 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
00554 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00555 }
00556
00557 srcY += src_y * s->linesize + src_x;
00558 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
00559 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
00560
00561 if (v->field_mode && v->ref_field_type[dir]) {
00562 srcY += s->current_picture_ptr->f.linesize[0];
00563 srcU += s->current_picture_ptr->f.linesize[1];
00564 srcV += s->current_picture_ptr->f.linesize[2];
00565 }
00566
00567
00568 if (s->flags & CODEC_FLAG_GRAY) {
00569 srcU = s->edge_emu_buffer + 18 * s->linesize;
00570 srcV = s->edge_emu_buffer + 18 * s->linesize;
00571 }
00572
00573 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00574 || s->h_edge_pos < 22 || v_edge_pos < 22
00575 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
00576 || (unsigned)(src_y - s->mspel) > v_edge_pos - (my&3) - 16 - s->mspel * 3) {
00577 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
00578
00579 srcY -= s->mspel * (1 + s->linesize);
00580 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
00581 17 + s->mspel * 2, 17 + s->mspel * 2,
00582 src_x - s->mspel, src_y - s->mspel,
00583 s->h_edge_pos, v_edge_pos);
00584 srcY = s->edge_emu_buffer;
00585 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
00586 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
00587 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
00588 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
00589 srcU = uvbuf;
00590 srcV = uvbuf + 16;
00591
00592 if (v->rangeredfrm) {
00593 int i, j;
00594 uint8_t *src, *src2;
00595
00596 src = srcY;
00597 for (j = 0; j < 17 + s->mspel * 2; j++) {
00598 for (i = 0; i < 17 + s->mspel * 2; i++)
00599 src[i] = ((src[i] - 128) >> 1) + 128;
00600 src += s->linesize;
00601 }
00602 src = srcU;
00603 src2 = srcV;
00604 for (j = 0; j < 9; j++) {
00605 for (i = 0; i < 9; i++) {
00606 src[i] = ((src[i] - 128) >> 1) + 128;
00607 src2[i] = ((src2[i] - 128) >> 1) + 128;
00608 }
00609 src += s->uvlinesize;
00610 src2 += s->uvlinesize;
00611 }
00612 }
00613
00614 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00615 int i, j;
00616 uint8_t *src, *src2;
00617
00618 src = srcY;
00619 for (j = 0; j < 17 + s->mspel * 2; j++) {
00620 for (i = 0; i < 17 + s->mspel * 2; i++)
00621 src[i] = v->luty[src[i]];
00622 src += s->linesize;
00623 }
00624 src = srcU;
00625 src2 = srcV;
00626 for (j = 0; j < 9; j++) {
00627 for (i = 0; i < 9; i++) {
00628 src[i] = v->lutuv[src[i]];
00629 src2[i] = v->lutuv[src2[i]];
00630 }
00631 src += s->uvlinesize;
00632 src2 += s->uvlinesize;
00633 }
00634 }
00635 srcY += s->mspel * (1 + s->linesize);
00636 }
00637
00638 if (v->field_mode && v->cur_field_type) {
00639 off = s->current_picture_ptr->f.linesize[0];
00640 off_uv = s->current_picture_ptr->f.linesize[1];
00641 } else {
00642 off = 0;
00643 off_uv = 0;
00644 }
00645 if (s->mspel) {
00646 dxy = ((my & 3) << 2) | (mx & 3);
00647 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
00648 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
00649 srcY += s->linesize * 8;
00650 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
00651 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
00652 } else {
00653 dxy = (my & 2) | ((mx & 2) >> 1);
00654 if (!v->rnd)
00655 dsp->put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
00656 else
00657 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
00658 }
00659
00660 if (s->flags & CODEC_FLAG_GRAY) return;
00661
00662 uvmx = (uvmx & 3) << 1;
00663 uvmy = (uvmy & 3) << 1;
00664 if (!v->rnd) {
00665 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
00666 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
00667 } else {
00668 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
00669 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
00670 }
00671 }
00672
00673 static inline int median4(int a, int b, int c, int d)
00674 {
00675 if (a < b) {
00676 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
00677 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
00678 } else {
00679 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
00680 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
00681 }
00682 }
00683
00686 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
00687 {
00688 MpegEncContext *s = &v->s;
00689 DSPContext *dsp = &v->s.dsp;
00690 uint8_t *srcY;
00691 int dxy, mx, my, src_x, src_y;
00692 int off;
00693 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
00694 int v_edge_pos = s->v_edge_pos >> v->field_mode;
00695
00696 if ((!v->field_mode ||
00697 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
00698 !v->s.last_picture.f.data[0])
00699 return;
00700
00701 mx = s->mv[dir][n][0];
00702 my = s->mv[dir][n][1];
00703
00704 if (!dir) {
00705 if (v->field_mode) {
00706 if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type)
00707 srcY = s->current_picture.f.data[0];
00708 else
00709 srcY = s->last_picture.f.data[0];
00710 } else
00711 srcY = s->last_picture.f.data[0];
00712 } else
00713 srcY = s->next_picture.f.data[0];
00714
00715 if (v->field_mode) {
00716 if (v->cur_field_type != v->ref_field_type[dir])
00717 my = my - 2 + 4 * v->cur_field_type;
00718 }
00719
00720 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
00721 int same_count = 0, opp_count = 0, k;
00722 int chosen_mv[2][4][2], f;
00723 int tx, ty;
00724 for (k = 0; k < 4; k++) {
00725 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
00726 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
00727 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
00728 opp_count += f;
00729 same_count += 1 - f;
00730 }
00731 f = opp_count > same_count;
00732 switch (f ? opp_count : same_count) {
00733 case 4:
00734 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
00735 chosen_mv[f][2][0], chosen_mv[f][3][0]);
00736 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
00737 chosen_mv[f][2][1], chosen_mv[f][3][1]);
00738 break;
00739 case 3:
00740 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
00741 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
00742 break;
00743 case 2:
00744 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
00745 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
00746 break;
00747 }
00748 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
00749 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
00750 for (k = 0; k < 4; k++)
00751 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
00752 }
00753
00754 if (v->fcm == ILACE_FRAME) {
00755 int qx, qy;
00756 int width = s->avctx->coded_width;
00757 int height = s->avctx->coded_height >> 1;
00758 qx = (s->mb_x * 16) + (mx >> 2);
00759 qy = (s->mb_y * 8) + (my >> 3);
00760
00761 if (qx < -17)
00762 mx -= 4 * (qx + 17);
00763 else if (qx > width)
00764 mx -= 4 * (qx - width);
00765 if (qy < -18)
00766 my -= 8 * (qy + 18);
00767 else if (qy > height + 1)
00768 my -= 8 * (qy - height - 1);
00769 }
00770
00771 if ((v->fcm == ILACE_FRAME) && fieldmv)
00772 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
00773 else
00774 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
00775 if (v->field_mode && v->cur_field_type)
00776 off += s->current_picture_ptr->f.linesize[0];
00777
00778 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
00779 if (!fieldmv)
00780 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
00781 else
00782 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
00783
00784 if (v->profile != PROFILE_ADVANCED) {
00785 src_x = av_clip(src_x, -16, s->mb_width * 16);
00786 src_y = av_clip(src_y, -16, s->mb_height * 16);
00787 } else {
00788 src_x = av_clip(src_x, -17, s->avctx->coded_width);
00789 if (v->fcm == ILACE_FRAME) {
00790 if (src_y & 1)
00791 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
00792 else
00793 src_y = av_clip(src_y, -18, s->avctx->coded_height);
00794 } else {
00795 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
00796 }
00797 }
00798
00799 srcY += src_y * s->linesize + src_x;
00800 if (v->field_mode && v->ref_field_type[dir])
00801 srcY += s->current_picture_ptr->f.linesize[0];
00802
00803 if (fieldmv && !(src_y & 1))
00804 v_edge_pos--;
00805 if (fieldmv && (src_y & 1) && src_y < 4)
00806 src_y--;
00807 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00808 || s->h_edge_pos < 13 || v_edge_pos < 23
00809 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
00810 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
00811 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
00812
00813 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
00814 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
00815 src_x - s->mspel, src_y - (s->mspel << fieldmv),
00816 s->h_edge_pos, v_edge_pos);
00817 srcY = s->edge_emu_buffer;
00818
00819 if (v->rangeredfrm) {
00820 int i, j;
00821 uint8_t *src;
00822
00823 src = srcY;
00824 for (j = 0; j < 9 + s->mspel * 2; j++) {
00825 for (i = 0; i < 9 + s->mspel * 2; i++)
00826 src[i] = ((src[i] - 128) >> 1) + 128;
00827 src += s->linesize << fieldmv;
00828 }
00829 }
00830
00831 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00832 int i, j;
00833 uint8_t *src;
00834
00835 src = srcY;
00836 for (j = 0; j < 9 + s->mspel * 2; j++) {
00837 for (i = 0; i < 9 + s->mspel * 2; i++)
00838 src[i] = v->luty[src[i]];
00839 src += s->linesize << fieldmv;
00840 }
00841 }
00842 srcY += s->mspel * (1 + (s->linesize << fieldmv));
00843 }
00844
00845 if (s->mspel) {
00846 dxy = ((my & 3) << 2) | (mx & 3);
00847 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
00848 } else {
00849 dxy = (my & 2) | ((mx & 2) >> 1);
00850 if (!v->rnd)
00851 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00852 else
00853 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00854 }
00855 }
00856
00857 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
00858 {
00859 int idx, i;
00860 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
00861
00862 idx = ((a[3] != flag) << 3)
00863 | ((a[2] != flag) << 2)
00864 | ((a[1] != flag) << 1)
00865 | (a[0] != flag);
00866 if (!idx) {
00867 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
00868 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
00869 return 4;
00870 } else if (count[idx] == 1) {
00871 switch (idx) {
00872 case 0x1:
00873 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
00874 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
00875 return 3;
00876 case 0x2:
00877 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
00878 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
00879 return 3;
00880 case 0x4:
00881 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
00882 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
00883 return 3;
00884 case 0x8:
00885 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
00886 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
00887 return 3;
00888 }
00889 } else if (count[idx] == 2) {
00890 int t1 = 0, t2 = 0;
00891 for (i = 0; i < 3; i++)
00892 if (!a[i]) {
00893 t1 = i;
00894 break;
00895 }
00896 for (i = t1 + 1; i < 4; i++)
00897 if (!a[i]) {
00898 t2 = i;
00899 break;
00900 }
00901 *tx = (mvx[t1] + mvx[t2]) / 2;
00902 *ty = (mvy[t1] + mvy[t2]) / 2;
00903 return 2;
00904 } else {
00905 return 0;
00906 }
00907 return -1;
00908 }
00909
00912 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
00913 {
00914 MpegEncContext *s = &v->s;
00915 DSPContext *dsp = &v->s.dsp;
00916 uint8_t *srcU, *srcV;
00917 int uvmx, uvmy, uvsrc_x, uvsrc_y;
00918 int k, tx = 0, ty = 0;
00919 int mvx[4], mvy[4], intra[4], mv_f[4];
00920 int valid_count;
00921 int chroma_ref_type = v->cur_field_type, off = 0;
00922 int v_edge_pos = s->v_edge_pos >> v->field_mode;
00923
00924 if (!v->field_mode && !v->s.last_picture.f.data[0])
00925 return;
00926 if (s->flags & CODEC_FLAG_GRAY)
00927 return;
00928
00929 for (k = 0; k < 4; k++) {
00930 mvx[k] = s->mv[dir][k][0];
00931 mvy[k] = s->mv[dir][k][1];
00932 intra[k] = v->mb_type[0][s->block_index[k]];
00933 if (v->field_mode)
00934 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
00935 }
00936
00937
00938 if (!v->field_mode || (v->field_mode && !v->numref)) {
00939 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
00940 if (!valid_count) {
00941 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
00942 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
00943 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
00944 return;
00945 }
00946 } else {
00947 int dominant = 0;
00948 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
00949 dominant = 1;
00950 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
00951 if (dominant)
00952 chroma_ref_type = !v->cur_field_type;
00953 }
00954 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
00955 return;
00956 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
00957 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
00958 uvmx = (tx + ((tx & 3) == 3)) >> 1;
00959 uvmy = (ty + ((ty & 3) == 3)) >> 1;
00960
00961 v->luma_mv[s->mb_x][0] = uvmx;
00962 v->luma_mv[s->mb_x][1] = uvmy;
00963
00964 if (v->fastuvmc) {
00965 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
00966 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
00967 }
00968
00969 if (v->cur_field_type != chroma_ref_type)
00970 uvmy += 2 - 4 * chroma_ref_type;
00971
00972 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00973 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00974
00975 if (v->profile != PROFILE_ADVANCED) {
00976 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
00977 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00978 } else {
00979 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
00980 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00981 }
00982
00983 if (!dir) {
00984 if (v->field_mode) {
00985 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
00986 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00987 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00988 } else {
00989 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00990 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00991 }
00992 } else {
00993 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00994 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00995 }
00996 } else {
00997 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00998 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00999 }
01000
01001 if (v->field_mode) {
01002 if (chroma_ref_type) {
01003 srcU += s->current_picture_ptr->f.linesize[1];
01004 srcV += s->current_picture_ptr->f.linesize[2];
01005 }
01006 off = v->cur_field_type ? s->current_picture_ptr->f.linesize[1] : 0;
01007 }
01008
01009 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
01010 || s->h_edge_pos < 18 || v_edge_pos < 18
01011 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
01012 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
01013 s->dsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
01014 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
01015 s->h_edge_pos >> 1, v_edge_pos >> 1);
01016 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
01017 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
01018 s->h_edge_pos >> 1, v_edge_pos >> 1);
01019 srcU = s->edge_emu_buffer;
01020 srcV = s->edge_emu_buffer + 16;
01021
01022
01023 if (v->rangeredfrm) {
01024 int i, j;
01025 uint8_t *src, *src2;
01026
01027 src = srcU;
01028 src2 = srcV;
01029 for (j = 0; j < 9; j++) {
01030 for (i = 0; i < 9; i++) {
01031 src[i] = ((src[i] - 128) >> 1) + 128;
01032 src2[i] = ((src2[i] - 128) >> 1) + 128;
01033 }
01034 src += s->uvlinesize;
01035 src2 += s->uvlinesize;
01036 }
01037 }
01038
01039 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01040 int i, j;
01041 uint8_t *src, *src2;
01042
01043 src = srcU;
01044 src2 = srcV;
01045 for (j = 0; j < 9; j++) {
01046 for (i = 0; i < 9; i++) {
01047 src[i] = v->lutuv[src[i]];
01048 src2[i] = v->lutuv[src2[i]];
01049 }
01050 src += s->uvlinesize;
01051 src2 += s->uvlinesize;
01052 }
01053 }
01054 }
01055
01056
01057 uvmx = (uvmx & 3) << 1;
01058 uvmy = (uvmy & 3) << 1;
01059 if (!v->rnd) {
01060 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
01061 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
01062 } else {
01063 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
01064 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
01065 }
01066 }
01067
01070 static void vc1_mc_4mv_chroma4(VC1Context *v)
01071 {
01072 MpegEncContext *s = &v->s;
01073 DSPContext *dsp = &v->s.dsp;
01074 uint8_t *srcU, *srcV;
01075 int uvsrc_x, uvsrc_y;
01076 int uvmx_field[4], uvmy_field[4];
01077 int i, off, tx, ty;
01078 int fieldmv = v->blk_mv_type[s->block_index[0]];
01079 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
01080 int v_dist = fieldmv ? 1 : 4;
01081 int v_edge_pos = s->v_edge_pos >> 1;
01082
01083 if (!v->s.last_picture.f.data[0])
01084 return;
01085 if (s->flags & CODEC_FLAG_GRAY)
01086 return;
01087
01088 for (i = 0; i < 4; i++) {
01089 tx = s->mv[0][i][0];
01090 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
01091 ty = s->mv[0][i][1];
01092 if (fieldmv)
01093 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
01094 else
01095 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
01096 }
01097
01098 for (i = 0; i < 4; i++) {
01099 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
01100 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
01101 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
01102
01103 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
01104 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
01105 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
01106 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
01107 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
01108 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
01109
01110 if (fieldmv && !(uvsrc_y & 1))
01111 v_edge_pos--;
01112 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
01113 uvsrc_y--;
01114 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
01115 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
01116 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
01117 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
01118 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
01119 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
01120 s->h_edge_pos >> 1, v_edge_pos);
01121 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
01122 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
01123 s->h_edge_pos >> 1, v_edge_pos);
01124 srcU = s->edge_emu_buffer;
01125 srcV = s->edge_emu_buffer + 16;
01126
01127
01128 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01129 int i, j;
01130 uint8_t *src, *src2;
01131
01132 src = srcU;
01133 src2 = srcV;
01134 for (j = 0; j < 5; j++) {
01135 for (i = 0; i < 5; i++) {
01136 src[i] = v->lutuv[src[i]];
01137 src2[i] = v->lutuv[src2[i]];
01138 }
01139 src += s->uvlinesize << 1;
01140 src2 += s->uvlinesize << 1;
01141 }
01142 }
01143 }
01144 if (!v->rnd) {
01145 dsp->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
01146 dsp->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
01147 } else {
01148 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
01149 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
01150 }
01151 }
01152 }
01153
01154
01165 #define GET_MQUANT() \
01166 if (v->dquantfrm) { \
01167 int edges = 0; \
01168 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
01169 if (v->dqbilevel) { \
01170 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
01171 } else { \
01172 mqdiff = get_bits(gb, 3); \
01173 if (mqdiff != 7) \
01174 mquant = v->pq + mqdiff; \
01175 else \
01176 mquant = get_bits(gb, 5); \
01177 } \
01178 } \
01179 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
01180 edges = 1 << v->dqsbedge; \
01181 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
01182 edges = (3 << v->dqsbedge) % 15; \
01183 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
01184 edges = 15; \
01185 if ((edges&1) && !s->mb_x) \
01186 mquant = v->altpq; \
01187 if ((edges&2) && s->first_slice_line) \
01188 mquant = v->altpq; \
01189 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
01190 mquant = v->altpq; \
01191 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
01192 mquant = v->altpq; \
01193 }
01194
01202 #define GET_MVDATA(_dmv_x, _dmv_y) \
01203 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
01204 VC1_MV_DIFF_VLC_BITS, 2); \
01205 if (index > 36) { \
01206 mb_has_coeffs = 1; \
01207 index -= 37; \
01208 } else \
01209 mb_has_coeffs = 0; \
01210 s->mb_intra = 0; \
01211 if (!index) { \
01212 _dmv_x = _dmv_y = 0; \
01213 } else if (index == 35) { \
01214 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
01215 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
01216 } else if (index == 36) { \
01217 _dmv_x = 0; \
01218 _dmv_y = 0; \
01219 s->mb_intra = 1; \
01220 } else { \
01221 index1 = index % 6; \
01222 if (!s->quarter_sample && index1 == 5) val = 1; \
01223 else val = 0; \
01224 if (size_table[index1] - val > 0) \
01225 val = get_bits(gb, size_table[index1] - val); \
01226 else val = 0; \
01227 sign = 0 - (val&1); \
01228 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
01229 \
01230 index1 = index / 6; \
01231 if (!s->quarter_sample && index1 == 5) val = 1; \
01232 else val = 0; \
01233 if (size_table[index1] - val > 0) \
01234 val = get_bits(gb, size_table[index1] - val); \
01235 else val = 0; \
01236 sign = 0 - (val & 1); \
01237 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
01238 }
01239
01240 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
01241 int *dmv_y, int *pred_flag)
01242 {
01243 int index, index1;
01244 int extend_x = 0, extend_y = 0;
01245 GetBitContext *gb = &v->s.gb;
01246 int bits, esc;
01247 int val, sign;
01248 const int* offs_tab;
01249
01250 if (v->numref) {
01251 bits = VC1_2REF_MVDATA_VLC_BITS;
01252 esc = 125;
01253 } else {
01254 bits = VC1_1REF_MVDATA_VLC_BITS;
01255 esc = 71;
01256 }
01257 switch (v->dmvrange) {
01258 case 1:
01259 extend_x = 1;
01260 break;
01261 case 2:
01262 extend_y = 1;
01263 break;
01264 case 3:
01265 extend_x = extend_y = 1;
01266 break;
01267 }
01268 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
01269 if (index == esc) {
01270 *dmv_x = get_bits(gb, v->k_x);
01271 *dmv_y = get_bits(gb, v->k_y);
01272 if (v->numref) {
01273 *pred_flag = *dmv_y & 1;
01274 *dmv_y = (*dmv_y + *pred_flag) >> 1;
01275 }
01276 }
01277 else {
01278 if (extend_x)
01279 offs_tab = offset_table2;
01280 else
01281 offs_tab = offset_table1;
01282 index1 = (index + 1) % 9;
01283 if (index1 != 0) {
01284 val = get_bits(gb, index1 + extend_x);
01285 sign = 0 -(val & 1);
01286 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
01287 } else
01288 *dmv_x = 0;
01289 if (extend_y)
01290 offs_tab = offset_table2;
01291 else
01292 offs_tab = offset_table1;
01293 index1 = (index + 1) / 9;
01294 if (index1 > v->numref) {
01295 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
01296 sign = 0 - (val & 1);
01297 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
01298 } else
01299 *dmv_y = 0;
01300 if (v->numref)
01301 *pred_flag = index1 & 1;
01302 }
01303 }
01304
01305 static av_always_inline int scaleforsame_x(VC1Context *v, int n , int dir)
01306 {
01307 int scaledvalue, refdist;
01308 int scalesame1, scalesame2;
01309 int scalezone1_x, zone1offset_x;
01310 int table_index = dir ^ v->second_field;
01311
01312 if (v->s.pict_type != AV_PICTURE_TYPE_B)
01313 refdist = v->refdist;
01314 else
01315 refdist = dir ? v->brfd : v->frfd;
01316 if (refdist > 3)
01317 refdist = 3;
01318 scalesame1 = vc1_field_mvpred_scales[table_index][1][refdist];
01319 scalesame2 = vc1_field_mvpred_scales[table_index][2][refdist];
01320 scalezone1_x = vc1_field_mvpred_scales[table_index][3][refdist];
01321 zone1offset_x = vc1_field_mvpred_scales[table_index][5][refdist];
01322
01323 if (FFABS(n) > 255)
01324 scaledvalue = n;
01325 else {
01326 if (FFABS(n) < scalezone1_x)
01327 scaledvalue = (n * scalesame1) >> 8;
01328 else {
01329 if (n < 0)
01330 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
01331 else
01332 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
01333 }
01334 }
01335 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
01336 }
01337
01338 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n , int dir)
01339 {
01340 int scaledvalue, refdist;
01341 int scalesame1, scalesame2;
01342 int scalezone1_y, zone1offset_y;
01343 int table_index = dir ^ v->second_field;
01344
01345 if (v->s.pict_type != AV_PICTURE_TYPE_B)
01346 refdist = v->refdist;
01347 else
01348 refdist = dir ? v->brfd : v->frfd;
01349 if (refdist > 3)
01350 refdist = 3;
01351 scalesame1 = vc1_field_mvpred_scales[table_index][1][refdist];
01352 scalesame2 = vc1_field_mvpred_scales[table_index][2][refdist];
01353 scalezone1_y = vc1_field_mvpred_scales[table_index][4][refdist];
01354 zone1offset_y = vc1_field_mvpred_scales[table_index][6][refdist];
01355
01356 if (FFABS(n) > 63)
01357 scaledvalue = n;
01358 else {
01359 if (FFABS(n) < scalezone1_y)
01360 scaledvalue = (n * scalesame1) >> 8;
01361 else {
01362 if (n < 0)
01363 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
01364 else
01365 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
01366 }
01367 }
01368
01369 if (v->cur_field_type && !v->ref_field_type[dir])
01370 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
01371 else
01372 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
01373 }
01374
01375 static av_always_inline int scaleforopp_x(VC1Context *v, int n )
01376 {
01377 int scalezone1_x, zone1offset_x;
01378 int scaleopp1, scaleopp2, brfd;
01379 int scaledvalue;
01380
01381 brfd = FFMIN(v->brfd, 3);
01382 scalezone1_x = vc1_b_field_mvpred_scales[3][brfd];
01383 zone1offset_x = vc1_b_field_mvpred_scales[5][brfd];
01384 scaleopp1 = vc1_b_field_mvpred_scales[1][brfd];
01385 scaleopp2 = vc1_b_field_mvpred_scales[2][brfd];
01386
01387 if (FFABS(n) > 255)
01388 scaledvalue = n;
01389 else {
01390 if (FFABS(n) < scalezone1_x)
01391 scaledvalue = (n * scaleopp1) >> 8;
01392 else {
01393 if (n < 0)
01394 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
01395 else
01396 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
01397 }
01398 }
01399 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
01400 }
01401
01402 static av_always_inline int scaleforopp_y(VC1Context *v, int n , int dir)
01403 {
01404 int scalezone1_y, zone1offset_y;
01405 int scaleopp1, scaleopp2, brfd;
01406 int scaledvalue;
01407
01408 brfd = FFMIN(v->brfd, 3);
01409 scalezone1_y = vc1_b_field_mvpred_scales[4][brfd];
01410 zone1offset_y = vc1_b_field_mvpred_scales[6][brfd];
01411 scaleopp1 = vc1_b_field_mvpred_scales[1][brfd];
01412 scaleopp2 = vc1_b_field_mvpred_scales[2][brfd];
01413
01414 if (FFABS(n) > 63)
01415 scaledvalue = n;
01416 else {
01417 if (FFABS(n) < scalezone1_y)
01418 scaledvalue = (n * scaleopp1) >> 8;
01419 else {
01420 if (n < 0)
01421 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
01422 else
01423 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
01424 }
01425 }
01426 if (v->cur_field_type && !v->ref_field_type[dir]) {
01427 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
01428 } else {
01429 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
01430 }
01431 }
01432
01433 static av_always_inline int scaleforsame(VC1Context *v, int i, int n ,
01434 int dim, int dir)
01435 {
01436 int brfd, scalesame;
01437 int hpel = 1 - v->s.quarter_sample;
01438
01439 n >>= hpel;
01440 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
01441 if (dim)
01442 n = scaleforsame_y(v, i, n, dir) << hpel;
01443 else
01444 n = scaleforsame_x(v, n, dir) << hpel;
01445 return n;
01446 }
01447 brfd = FFMIN(v->brfd, 3);
01448 scalesame = vc1_b_field_mvpred_scales[0][brfd];
01449
01450 n = (n * scalesame >> 8) << hpel;
01451 return n;
01452 }
01453
01454 static av_always_inline int scaleforopp(VC1Context *v, int n ,
01455 int dim, int dir)
01456 {
01457 int refdist, scaleopp;
01458 int hpel = 1 - v->s.quarter_sample;
01459
01460 n >>= hpel;
01461 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
01462 if (dim)
01463 n = scaleforopp_y(v, n, dir) << hpel;
01464 else
01465 n = scaleforopp_x(v, n) << hpel;
01466 return n;
01467 }
01468 if (v->s.pict_type != AV_PICTURE_TYPE_B)
01469 refdist = FFMIN(v->refdist, 3);
01470 else
01471 refdist = dir ? v->brfd : v->frfd;
01472 scaleopp = vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
01473
01474 n = (n * scaleopp >> 8) << hpel;
01475 return n;
01476 }
01477
01480 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
01481 int mv1, int r_x, int r_y, uint8_t* is_intra,
01482 int pred_flag, int dir)
01483 {
01484 MpegEncContext *s = &v->s;
01485 int xy, wrap, off = 0;
01486 int16_t *A, *B, *C;
01487 int px, py;
01488 int sum;
01489 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
01490 int opposit, a_f, b_f, c_f;
01491 int16_t field_predA[2];
01492 int16_t field_predB[2];
01493 int16_t field_predC[2];
01494 int a_valid, b_valid, c_valid;
01495 int hybridmv_thresh, y_bias = 0;
01496
01497 if (v->mv_mode == MV_PMODE_MIXED_MV ||
01498 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
01499 mixedmv_pic = 1;
01500 else
01501 mixedmv_pic = 0;
01502
01503 dmv_x <<= 1 - s->quarter_sample;
01504 dmv_y <<= 1 - s->quarter_sample;
01505
01506 wrap = s->b8_stride;
01507 xy = s->block_index[n];
01508
01509 if (s->mb_intra) {
01510 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
01511 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
01512 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
01513 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
01514 if (mv1) {
01515 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
01516 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
01517 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
01518 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
01519 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
01520 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
01521 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
01522 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
01523 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
01524 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
01525 s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
01526 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
01527 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
01528 }
01529 return;
01530 }
01531
01532 C = s->current_picture.f.motion_val[dir][xy - 1 + v->blocks_off];
01533 A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
01534 if (mv1) {
01535 if (v->field_mode && mixedmv_pic)
01536 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
01537 else
01538 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
01539 } else {
01540
01541 switch (n) {
01542 case 0:
01543 off = (s->mb_x > 0) ? -1 : 1;
01544 break;
01545 case 1:
01546 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
01547 break;
01548 case 2:
01549 off = 1;
01550 break;
01551 case 3:
01552 off = -1;
01553 }
01554 }
01555 B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
01556
01557 a_valid = !s->first_slice_line || (n == 2 || n == 3);
01558 b_valid = a_valid && (s->mb_width > 1);
01559 c_valid = s->mb_x || (n == 1 || n == 3);
01560 if (v->field_mode) {
01561 a_valid = a_valid && !is_intra[xy - wrap];
01562 b_valid = b_valid && !is_intra[xy - wrap + off];
01563 c_valid = c_valid && !is_intra[xy - 1];
01564 }
01565
01566 if (a_valid) {
01567 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
01568 num_oppfield += a_f;
01569 num_samefield += 1 - a_f;
01570 field_predA[0] = A[0];
01571 field_predA[1] = A[1];
01572 } else {
01573 field_predA[0] = field_predA[1] = 0;
01574 a_f = 0;
01575 }
01576 if (b_valid) {
01577 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
01578 num_oppfield += b_f;
01579 num_samefield += 1 - b_f;
01580 field_predB[0] = B[0];
01581 field_predB[1] = B[1];
01582 } else {
01583 field_predB[0] = field_predB[1] = 0;
01584 b_f = 0;
01585 }
01586 if (c_valid) {
01587 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
01588 num_oppfield += c_f;
01589 num_samefield += 1 - c_f;
01590 field_predC[0] = C[0];
01591 field_predC[1] = C[1];
01592 } else {
01593 field_predC[0] = field_predC[1] = 0;
01594 c_f = 0;
01595 }
01596
01597 if (v->field_mode) {
01598 if (num_samefield <= num_oppfield)
01599 opposit = 1 - pred_flag;
01600 else
01601 opposit = pred_flag;
01602 } else
01603 opposit = 0;
01604 if (opposit) {
01605 if (a_valid && !a_f) {
01606 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
01607 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
01608 }
01609 if (b_valid && !b_f) {
01610 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
01611 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
01612 }
01613 if (c_valid && !c_f) {
01614 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
01615 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
01616 }
01617 v->mv_f[dir][xy + v->blocks_off] = 1;
01618 v->ref_field_type[dir] = !v->cur_field_type;
01619 } else {
01620 if (a_valid && a_f) {
01621 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
01622 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
01623 }
01624 if (b_valid && b_f) {
01625 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
01626 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
01627 }
01628 if (c_valid && c_f) {
01629 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
01630 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
01631 }
01632 v->mv_f[dir][xy + v->blocks_off] = 0;
01633 v->ref_field_type[dir] = v->cur_field_type;
01634 }
01635
01636 if (a_valid) {
01637 px = field_predA[0];
01638 py = field_predA[1];
01639 } else if (c_valid) {
01640 px = field_predC[0];
01641 py = field_predC[1];
01642 } else if (b_valid) {
01643 px = field_predB[0];
01644 py = field_predB[1];
01645 } else {
01646 px = 0;
01647 py = 0;
01648 }
01649
01650 if (num_samefield + num_oppfield > 1) {
01651 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
01652 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
01653 }
01654
01655
01656 if (!v->field_mode) {
01657 int qx, qy, X, Y;
01658 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
01659 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
01660 X = (s->mb_width << 6) - 4;
01661 Y = (s->mb_height << 6) - 4;
01662 if (mv1) {
01663 if (qx + px < -60) px = -60 - qx;
01664 if (qy + py < -60) py = -60 - qy;
01665 } else {
01666 if (qx + px < -28) px = -28 - qx;
01667 if (qy + py < -28) py = -28 - qy;
01668 }
01669 if (qx + px > X) px = X - qx;
01670 if (qy + py > Y) py = Y - qy;
01671 }
01672
01673 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
01674
01675 hybridmv_thresh = 32;
01676 if (a_valid && c_valid) {
01677 if (is_intra[xy - wrap])
01678 sum = FFABS(px) + FFABS(py);
01679 else
01680 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
01681 if (sum > hybridmv_thresh) {
01682 if (get_bits1(&s->gb)) {
01683 px = field_predA[0];
01684 py = field_predA[1];
01685 } else {
01686 px = field_predC[0];
01687 py = field_predC[1];
01688 }
01689 } else {
01690 if (is_intra[xy - 1])
01691 sum = FFABS(px) + FFABS(py);
01692 else
01693 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
01694 if (sum > hybridmv_thresh) {
01695 if (get_bits1(&s->gb)) {
01696 px = field_predA[0];
01697 py = field_predA[1];
01698 } else {
01699 px = field_predC[0];
01700 py = field_predC[1];
01701 }
01702 }
01703 }
01704 }
01705 }
01706
01707 if (v->field_mode && !s->quarter_sample) {
01708 r_x <<= 1;
01709 r_y <<= 1;
01710 }
01711 if (v->field_mode && v->numref)
01712 r_y >>= 1;
01713 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
01714 y_bias = 1;
01715
01716 s->mv[dir][n][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
01717 s->mv[dir][n][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
01718 if (mv1) {
01719 s->current_picture.f.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
01720 s->current_picture.f.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
01721 s->current_picture.f.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
01722 s->current_picture.f.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
01723 s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
01724 s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
01725 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
01726 v->mv_f[dir][xy + wrap + v->blocks_off] = v->mv_f[dir][xy + wrap + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
01727 }
01728 }
01729
01732 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
01733 int mvn, int r_x, int r_y, uint8_t* is_intra)
01734 {
01735 MpegEncContext *s = &v->s;
01736 int xy, wrap, off = 0;
01737 int A[2], B[2], C[2];
01738 int px, py;
01739 int a_valid = 0, b_valid = 0, c_valid = 0;
01740 int field_a, field_b, field_c;
01741 int total_valid, num_samefield, num_oppfield;
01742 int pos_c, pos_b, n_adj;
01743
01744 wrap = s->b8_stride;
01745 xy = s->block_index[n];
01746
01747 if (s->mb_intra) {
01748 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
01749 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
01750 s->current_picture.f.motion_val[1][xy][0] = 0;
01751 s->current_picture.f.motion_val[1][xy][1] = 0;
01752 if (mvn == 1) {
01753 s->current_picture.f.motion_val[0][xy + 1][0] = 0;
01754 s->current_picture.f.motion_val[0][xy + 1][1] = 0;
01755 s->current_picture.f.motion_val[0][xy + wrap][0] = 0;
01756 s->current_picture.f.motion_val[0][xy + wrap][1] = 0;
01757 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
01758 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
01759 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
01760 s->current_picture.f.motion_val[1][xy + 1][0] = 0;
01761 s->current_picture.f.motion_val[1][xy + 1][1] = 0;
01762 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
01763 s->current_picture.f.motion_val[1][xy + wrap][1] = 0;
01764 s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
01765 s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
01766 }
01767 return;
01768 }
01769
01770 off = ((n == 0) || (n == 1)) ? 1 : -1;
01771
01772 if (s->mb_x || (n == 1) || (n == 3)) {
01773 if ((v->blk_mv_type[xy])
01774 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) {
01775 A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
01776 A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
01777 a_valid = 1;
01778 } else {
01779 A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
01780 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
01781 A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
01782 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
01783 a_valid = 1;
01784 }
01785 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
01786 a_valid = 0;
01787 A[0] = A[1] = 0;
01788 }
01789 } else
01790 A[0] = A[1] = 0;
01791
01792 B[0] = B[1] = C[0] = C[1] = 0;
01793 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
01794 if (!s->first_slice_line) {
01795 if (!v->is_intra[s->mb_x - s->mb_stride]) {
01796 b_valid = 1;
01797 n_adj = n | 2;
01798 pos_b = s->block_index[n_adj] - 2 * wrap;
01799 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
01800 n_adj = (n & 2) | (n & 1);
01801 }
01802 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
01803 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
01804 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
01805 B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
01806 B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
01807 }
01808 }
01809 if (s->mb_width > 1) {
01810 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
01811 c_valid = 1;
01812 n_adj = 2;
01813 pos_c = s->block_index[2] - 2 * wrap + 2;
01814 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
01815 n_adj = n & 2;
01816 }
01817 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
01818 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
01819 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
01820 C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
01821 C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
01822 }
01823 if (s->mb_x == s->mb_width - 1) {
01824 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
01825 c_valid = 1;
01826 n_adj = 3;
01827 pos_c = s->block_index[3] - 2 * wrap - 2;
01828 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
01829 n_adj = n | 1;
01830 }
01831 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
01832 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
01833 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
01834 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
01835 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
01836 }
01837 } else
01838 c_valid = 0;
01839 }
01840 }
01841 }
01842 }
01843 } else {
01844 pos_b = s->block_index[1];
01845 b_valid = 1;
01846 B[0] = s->current_picture.f.motion_val[0][pos_b][0];
01847 B[1] = s->current_picture.f.motion_val[0][pos_b][1];
01848 pos_c = s->block_index[0];
01849 c_valid = 1;
01850 C[0] = s->current_picture.f.motion_val[0][pos_c][0];
01851 C[1] = s->current_picture.f.motion_val[0][pos_c][1];
01852 }
01853
01854 total_valid = a_valid + b_valid + c_valid;
01855
01856 if (!s->mb_x && !(n == 1 || n == 3)) {
01857 A[0] = A[1] = 0;
01858 }
01859
01860 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
01861 B[0] = B[1] = C[0] = C[1] = 0;
01862 }
01863 if (!v->blk_mv_type[xy]) {
01864 if (s->mb_width == 1) {
01865 px = B[0];
01866 py = B[1];
01867 } else {
01868 if (total_valid >= 2) {
01869 px = mid_pred(A[0], B[0], C[0]);
01870 py = mid_pred(A[1], B[1], C[1]);
01871 } else if (total_valid) {
01872 if (a_valid) { px = A[0]; py = A[1]; }
01873 if (b_valid) { px = B[0]; py = B[1]; }
01874 if (c_valid) { px = C[0]; py = C[1]; }
01875 } else
01876 px = py = 0;
01877 }
01878 } else {
01879 if (a_valid)
01880 field_a = (A[1] & 4) ? 1 : 0;
01881 else
01882 field_a = 0;
01883 if (b_valid)
01884 field_b = (B[1] & 4) ? 1 : 0;
01885 else
01886 field_b = 0;
01887 if (c_valid)
01888 field_c = (C[1] & 4) ? 1 : 0;
01889 else
01890 field_c = 0;
01891
01892 num_oppfield = field_a + field_b + field_c;
01893 num_samefield = total_valid - num_oppfield;
01894 if (total_valid == 3) {
01895 if ((num_samefield == 3) || (num_oppfield == 3)) {
01896 px = mid_pred(A[0], B[0], C[0]);
01897 py = mid_pred(A[1], B[1], C[1]);
01898 } else if (num_samefield >= num_oppfield) {
01899
01900
01901 px = !field_a ? A[0] : B[0];
01902 py = !field_a ? A[1] : B[1];
01903 } else {
01904 px = field_a ? A[0] : B[0];
01905 py = field_a ? A[1] : B[1];
01906 }
01907 } else if (total_valid == 2) {
01908 if (num_samefield >= num_oppfield) {
01909 if (!field_a && a_valid) {
01910 px = A[0];
01911 py = A[1];
01912 } else if (!field_b && b_valid) {
01913 px = B[0];
01914 py = B[1];
01915 } else if (c_valid) {
01916 px = C[0];
01917 py = C[1];
01918 } else px = py = 0;
01919 } else {
01920 if (field_a && a_valid) {
01921 px = A[0];
01922 py = A[1];
01923 } else if (field_b && b_valid) {
01924 px = B[0];
01925 py = B[1];
01926 } else if (c_valid) {
01927 px = C[0];
01928 py = C[1];
01929 }
01930 }
01931 } else if (total_valid == 1) {
01932 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
01933 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
01934 } else
01935 px = py = 0;
01936 }
01937
01938
01939 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
01940 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
01941 if (mvn == 1) {
01942 s->current_picture.f.motion_val[0][xy + 1 ][0] = s->current_picture.f.motion_val[0][xy][0];
01943 s->current_picture.f.motion_val[0][xy + 1 ][1] = s->current_picture.f.motion_val[0][xy][1];
01944 s->current_picture.f.motion_val[0][xy + wrap ][0] = s->current_picture.f.motion_val[0][xy][0];
01945 s->current_picture.f.motion_val[0][xy + wrap ][1] = s->current_picture.f.motion_val[0][xy][1];
01946 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
01947 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
01948 } else if (mvn == 2) {
01949 s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
01950 s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
01951 s->mv[0][n + 1][0] = s->mv[0][n][0];
01952 s->mv[0][n + 1][1] = s->mv[0][n][1];
01953 }
01954 }
01955
01958 static void vc1_interp_mc(VC1Context *v)
01959 {
01960 MpegEncContext *s = &v->s;
01961 DSPContext *dsp = &v->s.dsp;
01962 uint8_t *srcY, *srcU, *srcV;
01963 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
01964 int off, off_uv;
01965 int v_edge_pos = s->v_edge_pos >> v->field_mode;
01966
01967 if (!v->field_mode && !v->s.next_picture.f.data[0])
01968 return;
01969
01970 mx = s->mv[1][0][0];
01971 my = s->mv[1][0][1];
01972 uvmx = (mx + ((mx & 3) == 3)) >> 1;
01973 uvmy = (my + ((my & 3) == 3)) >> 1;
01974 if (v->field_mode) {
01975 if (v->cur_field_type != v->ref_field_type[1])
01976 my = my - 2 + 4 * v->cur_field_type;
01977 uvmy = uvmy - 2 + 4 * v->cur_field_type;
01978 }
01979 if (v->fastuvmc) {
01980 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
01981 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
01982 }
01983 srcY = s->next_picture.f.data[0];
01984 srcU = s->next_picture.f.data[1];
01985 srcV = s->next_picture.f.data[2];
01986
01987 src_x = s->mb_x * 16 + (mx >> 2);
01988 src_y = s->mb_y * 16 + (my >> 2);
01989 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
01990 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
01991
01992 if (v->profile != PROFILE_ADVANCED) {
01993 src_x = av_clip( src_x, -16, s->mb_width * 16);
01994 src_y = av_clip( src_y, -16, s->mb_height * 16);
01995 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
01996 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
01997 } else {
01998 src_x = av_clip( src_x, -17, s->avctx->coded_width);
01999 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
02000 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
02001 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
02002 }
02003
02004 srcY += src_y * s->linesize + src_x;
02005 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
02006 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
02007
02008 if (v->field_mode && v->ref_field_type[1]) {
02009 srcY += s->current_picture_ptr->f.linesize[0];
02010 srcU += s->current_picture_ptr->f.linesize[1];
02011 srcV += s->current_picture_ptr->f.linesize[2];
02012 }
02013
02014
02015 if (s->flags & CODEC_FLAG_GRAY) {
02016 srcU = s->edge_emu_buffer + 18 * s->linesize;
02017 srcV = s->edge_emu_buffer + 18 * s->linesize;
02018 }
02019
02020 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
02021 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 16 - s->mspel * 3
02022 || (unsigned)(src_y - s->mspel) > v_edge_pos - (my & 3) - 16 - s->mspel * 3) {
02023 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
02024
02025 srcY -= s->mspel * (1 + s->linesize);
02026 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
02027 17 + s->mspel * 2, 17 + s->mspel * 2,
02028 src_x - s->mspel, src_y - s->mspel,
02029 s->h_edge_pos, v_edge_pos);
02030 srcY = s->edge_emu_buffer;
02031 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
02032 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
02033 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
02034 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
02035 srcU = uvbuf;
02036 srcV = uvbuf + 16;
02037
02038 if (v->rangeredfrm) {
02039 int i, j;
02040 uint8_t *src, *src2;
02041
02042 src = srcY;
02043 for (j = 0; j < 17 + s->mspel * 2; j++) {
02044 for (i = 0; i < 17 + s->mspel * 2; i++)
02045 src[i] = ((src[i] - 128) >> 1) + 128;
02046 src += s->linesize;
02047 }
02048 src = srcU;
02049 src2 = srcV;
02050 for (j = 0; j < 9; j++) {
02051 for (i = 0; i < 9; i++) {
02052 src[i] = ((src[i] - 128) >> 1) + 128;
02053 src2[i] = ((src2[i] - 128) >> 1) + 128;
02054 }
02055 src += s->uvlinesize;
02056 src2 += s->uvlinesize;
02057 }
02058 }
02059 srcY += s->mspel * (1 + s->linesize);
02060 }
02061
02062 if (v->field_mode && v->cur_field_type) {
02063 off = s->current_picture_ptr->f.linesize[0];
02064 off_uv = s->current_picture_ptr->f.linesize[1];
02065 } else {
02066 off = 0;
02067 off_uv = 0;
02068 }
02069
02070 if (s->mspel) {
02071 dxy = ((my & 3) << 2) | (mx & 3);
02072 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
02073 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
02074 srcY += s->linesize * 8;
02075 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
02076 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
02077 } else {
02078 dxy = (my & 2) | ((mx & 2) >> 1);
02079
02080 if (!v->rnd)
02081 dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
02082 else
02083 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
02084 }
02085
02086 if (s->flags & CODEC_FLAG_GRAY) return;
02087
02088 uvmx = (uvmx & 3) << 1;
02089 uvmy = (uvmy & 3) << 1;
02090 if (!v->rnd) {
02091 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
02092 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
02093 } else {
02094 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
02095 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
02096 }
02097 }
02098
02099 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
02100 {
02101 int n = bfrac;
02102
02103 #if B_FRACTION_DEN==256
02104 if (inv)
02105 n -= 256;
02106 if (!qs)
02107 return 2 * ((value * n + 255) >> 9);
02108 return (value * n + 128) >> 8;
02109 #else
02110 if (inv)
02111 n -= B_FRACTION_DEN;
02112 if (!qs)
02113 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
02114 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
02115 #endif
02116 }
02117
02118 static av_always_inline int scale_mv_intfi(int value, int bfrac, int inv,
02119 int qs, int qs_last)
02120 {
02121 int n = bfrac;
02122
02123 if (inv)
02124 n -= 256;
02125 n <<= !qs_last;
02126 if (!qs)
02127 return (value * n + 255) >> 9;
02128 else
02129 return (value * n + 128) >> 8;
02130 }
02131
02134 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
02135 int direct, int mode)
02136 {
02137 if (v->use_ic) {
02138 v->mv_mode2 = v->mv_mode;
02139 v->mv_mode = MV_PMODE_INTENSITY_COMP;
02140 }
02141 if (direct) {
02142 vc1_mc_1mv(v, 0);
02143 vc1_interp_mc(v);
02144 if (v->use_ic)
02145 v->mv_mode = v->mv_mode2;
02146 return;
02147 }
02148 if (mode == BMV_TYPE_INTERPOLATED) {
02149 vc1_mc_1mv(v, 0);
02150 vc1_interp_mc(v);
02151 if (v->use_ic)
02152 v->mv_mode = v->mv_mode2;
02153 return;
02154 }
02155
02156 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
02157 v->mv_mode = v->mv_mode2;
02158 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
02159 if (v->use_ic)
02160 v->mv_mode = v->mv_mode2;
02161 }
02162
02163 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
02164 int direct, int mvtype)
02165 {
02166 MpegEncContext *s = &v->s;
02167 int xy, wrap, off = 0;
02168 int16_t *A, *B, *C;
02169 int px, py;
02170 int sum;
02171 int r_x, r_y;
02172 const uint8_t *is_intra = v->mb_type[0];
02173
02174 r_x = v->range_x;
02175 r_y = v->range_y;
02176
02177 dmv_x[0] <<= 1 - s->quarter_sample;
02178 dmv_y[0] <<= 1 - s->quarter_sample;
02179 dmv_x[1] <<= 1 - s->quarter_sample;
02180 dmv_y[1] <<= 1 - s->quarter_sample;
02181
02182 wrap = s->b8_stride;
02183 xy = s->block_index[0];
02184
02185 if (s->mb_intra) {
02186 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
02187 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
02188 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
02189 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
02190 return;
02191 }
02192 if (!v->field_mode) {
02193 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
02194 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
02195 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
02196 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
02197
02198
02199 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));
02200 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));
02201 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));
02202 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));
02203 }
02204 if (direct) {
02205 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
02206 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
02207 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
02208 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
02209 return;
02210 }
02211
02212 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
02213 C = s->current_picture.f.motion_val[0][xy - 2];
02214 A = s->current_picture.f.motion_val[0][xy - wrap * 2];
02215 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
02216 B = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
02217
02218 if (!s->mb_x) C[0] = C[1] = 0;
02219 if (!s->first_slice_line) {
02220 if (s->mb_width == 1) {
02221 px = A[0];
02222 py = A[1];
02223 } else {
02224 px = mid_pred(A[0], B[0], C[0]);
02225 py = mid_pred(A[1], B[1], C[1]);
02226 }
02227 } else if (s->mb_x) {
02228 px = C[0];
02229 py = C[1];
02230 } else {
02231 px = py = 0;
02232 }
02233
02234 {
02235 int qx, qy, X, Y;
02236 if (v->profile < PROFILE_ADVANCED) {
02237 qx = (s->mb_x << 5);
02238 qy = (s->mb_y << 5);
02239 X = (s->mb_width << 5) - 4;
02240 Y = (s->mb_height << 5) - 4;
02241 if (qx + px < -28) px = -28 - qx;
02242 if (qy + py < -28) py = -28 - qy;
02243 if (qx + px > X) px = X - qx;
02244 if (qy + py > Y) py = Y - qy;
02245 } else {
02246 qx = (s->mb_x << 6);
02247 qy = (s->mb_y << 6);
02248 X = (s->mb_width << 6) - 4;
02249 Y = (s->mb_height << 6) - 4;
02250 if (qx + px < -60) px = -60 - qx;
02251 if (qy + py < -60) py = -60 - qy;
02252 if (qx + px > X) px = X - qx;
02253 if (qy + py > Y) py = Y - qy;
02254 }
02255 }
02256
02257 if (0 && !s->first_slice_line && s->mb_x) {
02258 if (is_intra[xy - wrap])
02259 sum = FFABS(px) + FFABS(py);
02260 else
02261 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
02262 if (sum > 32) {
02263 if (get_bits1(&s->gb)) {
02264 px = A[0];
02265 py = A[1];
02266 } else {
02267 px = C[0];
02268 py = C[1];
02269 }
02270 } else {
02271 if (is_intra[xy - 2])
02272 sum = FFABS(px) + FFABS(py);
02273 else
02274 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
02275 if (sum > 32) {
02276 if (get_bits1(&s->gb)) {
02277 px = A[0];
02278 py = A[1];
02279 } else {
02280 px = C[0];
02281 py = C[1];
02282 }
02283 }
02284 }
02285 }
02286
02287 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
02288 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
02289 }
02290 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
02291 C = s->current_picture.f.motion_val[1][xy - 2];
02292 A = s->current_picture.f.motion_val[1][xy - wrap * 2];
02293 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
02294 B = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
02295
02296 if (!s->mb_x)
02297 C[0] = C[1] = 0;
02298 if (!s->first_slice_line) {
02299 if (s->mb_width == 1) {
02300 px = A[0];
02301 py = A[1];
02302 } else {
02303 px = mid_pred(A[0], B[0], C[0]);
02304 py = mid_pred(A[1], B[1], C[1]);
02305 }
02306 } else if (s->mb_x) {
02307 px = C[0];
02308 py = C[1];
02309 } else {
02310 px = py = 0;
02311 }
02312
02313 {
02314 int qx, qy, X, Y;
02315 if (v->profile < PROFILE_ADVANCED) {
02316 qx = (s->mb_x << 5);
02317 qy = (s->mb_y << 5);
02318 X = (s->mb_width << 5) - 4;
02319 Y = (s->mb_height << 5) - 4;
02320 if (qx + px < -28) px = -28 - qx;
02321 if (qy + py < -28) py = -28 - qy;
02322 if (qx + px > X) px = X - qx;
02323 if (qy + py > Y) py = Y - qy;
02324 } else {
02325 qx = (s->mb_x << 6);
02326 qy = (s->mb_y << 6);
02327 X = (s->mb_width << 6) - 4;
02328 Y = (s->mb_height << 6) - 4;
02329 if (qx + px < -60) px = -60 - qx;
02330 if (qy + py < -60) py = -60 - qy;
02331 if (qx + px > X) px = X - qx;
02332 if (qy + py > Y) py = Y - qy;
02333 }
02334 }
02335
02336 if (0 && !s->first_slice_line && s->mb_x) {
02337 if (is_intra[xy - wrap])
02338 sum = FFABS(px) + FFABS(py);
02339 else
02340 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
02341 if (sum > 32) {
02342 if (get_bits1(&s->gb)) {
02343 px = A[0];
02344 py = A[1];
02345 } else {
02346 px = C[0];
02347 py = C[1];
02348 }
02349 } else {
02350 if (is_intra[xy - 2])
02351 sum = FFABS(px) + FFABS(py);
02352 else
02353 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
02354 if (sum > 32) {
02355 if (get_bits1(&s->gb)) {
02356 px = A[0];
02357 py = A[1];
02358 } else {
02359 px = C[0];
02360 py = C[1];
02361 }
02362 }
02363 }
02364 }
02365
02366
02367 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
02368 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
02369 }
02370 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
02371 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
02372 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
02373 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
02374 }
02375
02376 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
02377 {
02378 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
02379 MpegEncContext *s = &v->s;
02380 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02381
02382 if (v->bmvtype == BMV_TYPE_DIRECT) {
02383 int total_opp, k, f;
02384 if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
02385 s->mv[0][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
02386 v->bfraction, 0, s->quarter_sample, v->qs_last);
02387 s->mv[0][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
02388 v->bfraction, 0, s->quarter_sample, v->qs_last);
02389 s->mv[1][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
02390 v->bfraction, 1, s->quarter_sample, v->qs_last);
02391 s->mv[1][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
02392 v->bfraction, 1, s->quarter_sample, v->qs_last);
02393
02394 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
02395 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
02396 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
02397 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
02398 f = (total_opp > 2) ? 1 : 0;
02399 } else {
02400 s->mv[0][0][0] = s->mv[0][0][1] = 0;
02401 s->mv[1][0][0] = s->mv[1][0][1] = 0;
02402 f = 0;
02403 }
02404 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
02405 for (k = 0; k < 4; k++) {
02406 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
02407 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
02408 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
02409 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
02410 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
02411 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
02412 }
02413 return;
02414 }
02415 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
02416 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], pred_flag[0], 0);
02417 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], pred_flag[1], 1);
02418 return;
02419 }
02420 if (dir) {
02421 vc1_pred_mv(v, n, dmv_x[1], dmv_y[1], mv1, v->range_x, v->range_y, v->mb_type[0], pred_flag[1], 1);
02422 if (n == 3 || mv1) {
02423 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
02424 }
02425 } else {
02426 vc1_pred_mv(v, n, dmv_x[0], dmv_y[0], mv1, v->range_x, v->range_y, v->mb_type[0], pred_flag[0], 0);
02427 if (n == 3 || mv1) {
02428 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
02429 }
02430 }
02431 }
02432
02442 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
02443 int16_t **dc_val_ptr, int *dir_ptr)
02444 {
02445 int a, b, c, wrap, pred, scale;
02446 int16_t *dc_val;
02447 static const uint16_t dcpred[32] = {
02448 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
02449 114, 102, 93, 85, 79, 73, 68, 64,
02450 60, 57, 54, 51, 49, 47, 45, 43,
02451 41, 39, 38, 37, 35, 34, 33
02452 };
02453
02454
02455 if (n < 4) scale = s->y_dc_scale;
02456 else scale = s->c_dc_scale;
02457
02458 wrap = s->block_wrap[n];
02459 dc_val = s->dc_val[0] + s->block_index[n];
02460
02461
02462
02463
02464 c = dc_val[ - 1];
02465 b = dc_val[ - 1 - wrap];
02466 a = dc_val[ - wrap];
02467
02468 if (pq < 9 || !overlap) {
02469
02470 if (s->first_slice_line && (n != 2 && n != 3))
02471 b = a = dcpred[scale];
02472 if (s->mb_x == 0 && (n != 1 && n != 3))
02473 b = c = dcpred[scale];
02474 } else {
02475
02476 if (s->first_slice_line && (n != 2 && n != 3))
02477 b = a = 0;
02478 if (s->mb_x == 0 && (n != 1 && n != 3))
02479 b = c = 0;
02480 }
02481
02482 if (abs(a - b) <= abs(b - c)) {
02483 pred = c;
02484 *dir_ptr = 1;
02485 } else {
02486 pred = a;
02487 *dir_ptr = 0;
02488 }
02489
02490
02491 *dc_val_ptr = &dc_val[0];
02492 return pred;
02493 }
02494
02495
02507 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
02508 int a_avail, int c_avail,
02509 int16_t **dc_val_ptr, int *dir_ptr)
02510 {
02511 int a, b, c, wrap, pred;
02512 int16_t *dc_val;
02513 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02514 int q1, q2 = 0;
02515
02516 wrap = s->block_wrap[n];
02517 dc_val = s->dc_val[0] + s->block_index[n];
02518
02519
02520
02521
02522 c = dc_val[ - 1];
02523 b = dc_val[ - 1 - wrap];
02524 a = dc_val[ - wrap];
02525
02526 q1 = s->current_picture.f.qscale_table[mb_pos];
02527 if (c_avail && (n != 1 && n != 3)) {
02528 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
02529 if (q2 && q2 != q1)
02530 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
02531 }
02532 if (a_avail && (n != 2 && n != 3)) {
02533 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
02534 if (q2 && q2 != q1)
02535 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
02536 }
02537 if (a_avail && c_avail && (n != 3)) {
02538 int off = mb_pos;
02539 if (n != 1)
02540 off--;
02541 if (n != 2)
02542 off -= s->mb_stride;
02543 q2 = s->current_picture.f.qscale_table[off];
02544 if (q2 && q2 != q1)
02545 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
02546 }
02547
02548 if (a_avail && c_avail) {
02549 if (abs(a - b) <= abs(b - c)) {
02550 pred = c;
02551 *dir_ptr = 1;
02552 } else {
02553 pred = a;
02554 *dir_ptr = 0;
02555 }
02556 } else if (a_avail) {
02557 pred = a;
02558 *dir_ptr = 0;
02559 } else if (c_avail) {
02560 pred = c;
02561 *dir_ptr = 1;
02562 } else {
02563 pred = 0;
02564 *dir_ptr = 1;
02565 }
02566
02567
02568 *dc_val_ptr = &dc_val[0];
02569 return pred;
02570 }
02571
02573
02580 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
02581 uint8_t **coded_block_ptr)
02582 {
02583 int xy, wrap, pred, a, b, c;
02584
02585 xy = s->block_index[n];
02586 wrap = s->b8_stride;
02587
02588
02589
02590
02591 a = s->coded_block[xy - 1 ];
02592 b = s->coded_block[xy - 1 - wrap];
02593 c = s->coded_block[xy - wrap];
02594
02595 if (b == c) {
02596 pred = a;
02597 } else {
02598 pred = c;
02599 }
02600
02601
02602 *coded_block_ptr = &s->coded_block[xy];
02603
02604 return pred;
02605 }
02606
02616 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
02617 int *value, int codingset)
02618 {
02619 GetBitContext *gb = &v->s.gb;
02620 int index, escape, run = 0, level = 0, lst = 0;
02621
02622 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
02623 if (index != vc1_ac_sizes[codingset] - 1) {
02624 run = vc1_index_decode_table[codingset][index][0];
02625 level = vc1_index_decode_table[codingset][index][1];
02626 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
02627 if (get_bits1(gb))
02628 level = -level;
02629 } else {
02630 escape = decode210(gb);
02631 if (escape != 2) {
02632 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
02633 run = vc1_index_decode_table[codingset][index][0];
02634 level = vc1_index_decode_table[codingset][index][1];
02635 lst = index >= vc1_last_decode_table[codingset];
02636 if (escape == 0) {
02637 if (lst)
02638 level += vc1_last_delta_level_table[codingset][run];
02639 else
02640 level += vc1_delta_level_table[codingset][run];
02641 } else {
02642 if (lst)
02643 run += vc1_last_delta_run_table[codingset][level] + 1;
02644 else
02645 run += vc1_delta_run_table[codingset][level] + 1;
02646 }
02647 if (get_bits1(gb))
02648 level = -level;
02649 } else {
02650 int sign;
02651 lst = get_bits1(gb);
02652 if (v->s.esc3_level_length == 0) {
02653 if (v->pq < 8 || v->dquantfrm) {
02654 v->s.esc3_level_length = get_bits(gb, 3);
02655 if (!v->s.esc3_level_length)
02656 v->s.esc3_level_length = get_bits(gb, 2) + 8;
02657 } else {
02658 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
02659 }
02660 v->s.esc3_run_length = 3 + get_bits(gb, 2);
02661 }
02662 run = get_bits(gb, v->s.esc3_run_length);
02663 sign = get_bits1(gb);
02664 level = get_bits(gb, v->s.esc3_level_length);
02665 if (sign)
02666 level = -level;
02667 }
02668 }
02669
02670 *last = lst;
02671 *skip = run;
02672 *value = level;
02673 }
02674
02682 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
02683 int coded, int codingset)
02684 {
02685 GetBitContext *gb = &v->s.gb;
02686 MpegEncContext *s = &v->s;
02687 int dc_pred_dir = 0;
02688 int i;
02689 int16_t *dc_val;
02690 int16_t *ac_val, *ac_val2;
02691 int dcdiff;
02692
02693
02694 if (n < 4) {
02695 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02696 } else {
02697 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02698 }
02699 if (dcdiff < 0) {
02700 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
02701 return -1;
02702 }
02703 if (dcdiff) {
02704 if (dcdiff == 119 ) {
02705
02706 if (v->pq == 1) dcdiff = get_bits(gb, 10);
02707 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
02708 else dcdiff = get_bits(gb, 8);
02709 } else {
02710 if (v->pq == 1)
02711 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
02712 else if (v->pq == 2)
02713 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
02714 }
02715 if (get_bits1(gb))
02716 dcdiff = -dcdiff;
02717 }
02718
02719
02720 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
02721 *dc_val = dcdiff;
02722
02723
02724 if (n < 4) {
02725 block[0] = dcdiff * s->y_dc_scale;
02726 } else {
02727 block[0] = dcdiff * s->c_dc_scale;
02728 }
02729
02730 if (!coded) {
02731 goto not_coded;
02732 }
02733
02734
02735 i = 1;
02736
02737 {
02738 int last = 0, skip, value;
02739 const uint8_t *zz_table;
02740 int scale;
02741 int k;
02742
02743 scale = v->pq * 2 + v->halfpq;
02744
02745 if (v->s.ac_pred) {
02746 if (!dc_pred_dir)
02747 zz_table = v->zz_8x8[2];
02748 else
02749 zz_table = v->zz_8x8[3];
02750 } else
02751 zz_table = v->zz_8x8[1];
02752
02753 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02754 ac_val2 = ac_val;
02755 if (dc_pred_dir)
02756 ac_val -= 16;
02757 else
02758 ac_val -= 16 * s->block_wrap[n];
02759
02760 while (!last) {
02761 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
02762 i += skip;
02763 if (i > 63)
02764 break;
02765 block[zz_table[i++]] = value;
02766 }
02767
02768
02769 if (s->ac_pred) {
02770 if (dc_pred_dir) {
02771 for (k = 1; k < 8; k++)
02772 block[k << v->left_blk_sh] += ac_val[k];
02773 } else {
02774 for (k = 1; k < 8; k++)
02775 block[k << v->top_blk_sh] += ac_val[k + 8];
02776 }
02777 }
02778
02779 for (k = 1; k < 8; k++) {
02780 ac_val2[k] = block[k << v->left_blk_sh];
02781 ac_val2[k + 8] = block[k << v->top_blk_sh];
02782 }
02783
02784
02785 for (k = 1; k < 64; k++)
02786 if (block[k]) {
02787 block[k] *= scale;
02788 if (!v->pquantizer)
02789 block[k] += (block[k] < 0) ? -v->pq : v->pq;
02790 }
02791
02792 if (s->ac_pred) i = 63;
02793 }
02794
02795 not_coded:
02796 if (!coded) {
02797 int k, scale;
02798 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02799 ac_val2 = ac_val;
02800
02801 i = 0;
02802 scale = v->pq * 2 + v->halfpq;
02803 memset(ac_val2, 0, 16 * 2);
02804 if (dc_pred_dir) {
02805 ac_val -= 16;
02806 if (s->ac_pred)
02807 memcpy(ac_val2, ac_val, 8 * 2);
02808 } else {
02809 ac_val -= 16 * s->block_wrap[n];
02810 if (s->ac_pred)
02811 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
02812 }
02813
02814
02815 if (s->ac_pred) {
02816 if (dc_pred_dir) {
02817 for (k = 1; k < 8; k++) {
02818 block[k << v->left_blk_sh] = ac_val[k] * scale;
02819 if (!v->pquantizer && block[k << v->left_blk_sh])
02820 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
02821 }
02822 } else {
02823 for (k = 1; k < 8; k++) {
02824 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
02825 if (!v->pquantizer && block[k << v->top_blk_sh])
02826 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
02827 }
02828 }
02829 i = 63;
02830 }
02831 }
02832 s->block_last_index[n] = i;
02833
02834 return 0;
02835 }
02836
02845 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
02846 int coded, int codingset, int mquant)
02847 {
02848 GetBitContext *gb = &v->s.gb;
02849 MpegEncContext *s = &v->s;
02850 int dc_pred_dir = 0;
02851 int i;
02852 int16_t *dc_val;
02853 int16_t *ac_val, *ac_val2;
02854 int dcdiff;
02855 int a_avail = v->a_avail, c_avail = v->c_avail;
02856 int use_pred = s->ac_pred;
02857 int scale;
02858 int q1, q2 = 0;
02859 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02860
02861
02862 if (n < 4) {
02863 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02864 } else {
02865 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02866 }
02867 if (dcdiff < 0) {
02868 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
02869 return -1;
02870 }
02871 if (dcdiff) {
02872 if (dcdiff == 119 ) {
02873
02874 if (mquant == 1) dcdiff = get_bits(gb, 10);
02875 else if (mquant == 2) dcdiff = get_bits(gb, 9);
02876 else dcdiff = get_bits(gb, 8);
02877 } else {
02878 if (mquant == 1)
02879 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
02880 else if (mquant == 2)
02881 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
02882 }
02883 if (get_bits1(gb))
02884 dcdiff = -dcdiff;
02885 }
02886
02887
02888 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
02889 *dc_val = dcdiff;
02890
02891
02892 if (n < 4) {
02893 block[0] = dcdiff * s->y_dc_scale;
02894 } else {
02895 block[0] = dcdiff * s->c_dc_scale;
02896 }
02897
02898
02899 i = 1;
02900
02901
02902 if (!a_avail && !c_avail)
02903 use_pred = 0;
02904 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02905 ac_val2 = ac_val;
02906
02907 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
02908
02909 if (dc_pred_dir)
02910 ac_val -= 16;
02911 else
02912 ac_val -= 16 * s->block_wrap[n];
02913
02914 q1 = s->current_picture.f.qscale_table[mb_pos];
02915 if ( dc_pred_dir && c_avail && mb_pos)
02916 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
02917 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
02918 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
02919 if ( dc_pred_dir && n == 1)
02920 q2 = q1;
02921 if (!dc_pred_dir && n == 2)
02922 q2 = q1;
02923 if (n == 3)
02924 q2 = q1;
02925
02926 if (coded) {
02927 int last = 0, skip, value;
02928 const uint8_t *zz_table;
02929 int k;
02930
02931 if (v->s.ac_pred) {
02932 if (!use_pred && v->fcm == ILACE_FRAME) {
02933 zz_table = v->zzi_8x8;
02934 } else {
02935 if (!dc_pred_dir)
02936 zz_table = v->zz_8x8[2];
02937 else
02938 zz_table = v->zz_8x8[3];
02939 }
02940 } else {
02941 if (v->fcm != ILACE_FRAME)
02942 zz_table = v->zz_8x8[1];
02943 else
02944 zz_table = v->zzi_8x8;
02945 }
02946
02947 while (!last) {
02948 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
02949 i += skip;
02950 if (i > 63)
02951 break;
02952 block[zz_table[i++]] = value;
02953 }
02954
02955
02956 if (use_pred) {
02957
02958 if (q2 && q1 != q2) {
02959 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02960 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02961
02962 if (dc_pred_dir) {
02963 for (k = 1; k < 8; k++)
02964 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02965 } else {
02966 for (k = 1; k < 8; k++)
02967 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02968 }
02969 } else {
02970 if (dc_pred_dir) {
02971 for (k = 1; k < 8; k++)
02972 block[k << v->left_blk_sh] += ac_val[k];
02973 } else {
02974 for (k = 1; k < 8; k++)
02975 block[k << v->top_blk_sh] += ac_val[k + 8];
02976 }
02977 }
02978 }
02979
02980 for (k = 1; k < 8; k++) {
02981 ac_val2[k ] = block[k << v->left_blk_sh];
02982 ac_val2[k + 8] = block[k << v->top_blk_sh];
02983 }
02984
02985
02986 for (k = 1; k < 64; k++)
02987 if (block[k]) {
02988 block[k] *= scale;
02989 if (!v->pquantizer)
02990 block[k] += (block[k] < 0) ? -mquant : mquant;
02991 }
02992
02993 if (use_pred) i = 63;
02994 } else {
02995 int k;
02996
02997 memset(ac_val2, 0, 16 * 2);
02998 if (dc_pred_dir) {
02999 if (use_pred) {
03000 memcpy(ac_val2, ac_val, 8 * 2);
03001 if (q2 && q1 != q2) {
03002 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
03003 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
03004 for (k = 1; k < 8; k++)
03005 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03006 }
03007 }
03008 } else {
03009 if (use_pred) {
03010 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
03011 if (q2 && q1 != q2) {
03012 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
03013 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
03014 for (k = 1; k < 8; k++)
03015 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03016 }
03017 }
03018 }
03019
03020
03021 if (use_pred) {
03022 if (dc_pred_dir) {
03023 for (k = 1; k < 8; k++) {
03024 block[k << v->left_blk_sh] = ac_val2[k] * scale;
03025 if (!v->pquantizer && block[k << v->left_blk_sh])
03026 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
03027 }
03028 } else {
03029 for (k = 1; k < 8; k++) {
03030 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
03031 if (!v->pquantizer && block[k << v->top_blk_sh])
03032 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
03033 }
03034 }
03035 i = 63;
03036 }
03037 }
03038 s->block_last_index[n] = i;
03039
03040 return 0;
03041 }
03042
03051 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
03052 int coded, int mquant, int codingset)
03053 {
03054 GetBitContext *gb = &v->s.gb;
03055 MpegEncContext *s = &v->s;
03056 int dc_pred_dir = 0;
03057 int i;
03058 int16_t *dc_val;
03059 int16_t *ac_val, *ac_val2;
03060 int dcdiff;
03061 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
03062 int a_avail = v->a_avail, c_avail = v->c_avail;
03063 int use_pred = s->ac_pred;
03064 int scale;
03065 int q1, q2 = 0;
03066
03067 s->dsp.clear_block(block);
03068
03069
03070 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
03071
03072
03073 s->y_dc_scale = s->y_dc_scale_table[mquant];
03074 s->c_dc_scale = s->c_dc_scale_table[mquant];
03075
03076
03077 if (n < 4) {
03078 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
03079 } else {
03080 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
03081 }
03082 if (dcdiff < 0) {
03083 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
03084 return -1;
03085 }
03086 if (dcdiff) {
03087 if (dcdiff == 119 ) {
03088
03089 if (mquant == 1) dcdiff = get_bits(gb, 10);
03090 else if (mquant == 2) dcdiff = get_bits(gb, 9);
03091 else dcdiff = get_bits(gb, 8);
03092 } else {
03093 if (mquant == 1)
03094 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
03095 else if (mquant == 2)
03096 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
03097 }
03098 if (get_bits1(gb))
03099 dcdiff = -dcdiff;
03100 }
03101
03102
03103 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
03104 *dc_val = dcdiff;
03105
03106
03107
03108 if (n < 4) {
03109 block[0] = dcdiff * s->y_dc_scale;
03110 } else {
03111 block[0] = dcdiff * s->c_dc_scale;
03112 }
03113
03114
03115 i = 1;
03116
03117
03118 if (!a_avail) dc_pred_dir = 1;
03119 if (!c_avail) dc_pred_dir = 0;
03120 if (!a_avail && !c_avail) use_pred = 0;
03121 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
03122 ac_val2 = ac_val;
03123
03124 scale = mquant * 2 + v->halfpq;
03125
03126 if (dc_pred_dir)
03127 ac_val -= 16;
03128 else
03129 ac_val -= 16 * s->block_wrap[n];
03130
03131 q1 = s->current_picture.f.qscale_table[mb_pos];
03132 if (dc_pred_dir && c_avail && mb_pos)
03133 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
03134 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
03135 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
03136 if ( dc_pred_dir && n == 1)
03137 q2 = q1;
03138 if (!dc_pred_dir && n == 2)
03139 q2 = q1;
03140 if (n == 3) q2 = q1;
03141
03142 if (coded) {
03143 int last = 0, skip, value;
03144 int k;
03145
03146 while (!last) {
03147 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
03148 i += skip;
03149 if (i > 63)
03150 break;
03151 if (v->fcm == PROGRESSIVE)
03152 block[v->zz_8x8[0][i++]] = value;
03153 else {
03154 if (use_pred && (v->fcm == ILACE_FRAME)) {
03155 if (!dc_pred_dir)
03156 block[v->zz_8x8[2][i++]] = value;
03157 else
03158 block[v->zz_8x8[3][i++]] = value;
03159 } else {
03160 block[v->zzi_8x8[i++]] = value;
03161 }
03162 }
03163 }
03164
03165
03166 if (use_pred) {
03167
03168 if (q2 && q1 != q2) {
03169 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
03170 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
03171
03172 if (dc_pred_dir) {
03173 for (k = 1; k < 8; k++)
03174 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03175 } else {
03176 for (k = 1; k < 8; k++)
03177 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03178 }
03179 } else {
03180 if (dc_pred_dir) {
03181 for (k = 1; k < 8; k++)
03182 block[k << v->left_blk_sh] += ac_val[k];
03183 } else {
03184 for (k = 1; k < 8; k++)
03185 block[k << v->top_blk_sh] += ac_val[k + 8];
03186 }
03187 }
03188 }
03189
03190 for (k = 1; k < 8; k++) {
03191 ac_val2[k ] = block[k << v->left_blk_sh];
03192 ac_val2[k + 8] = block[k << v->top_blk_sh];
03193 }
03194
03195
03196 for (k = 1; k < 64; k++)
03197 if (block[k]) {
03198 block[k] *= scale;
03199 if (!v->pquantizer)
03200 block[k] += (block[k] < 0) ? -mquant : mquant;
03201 }
03202
03203 if (use_pred) i = 63;
03204 } else {
03205 int k;
03206
03207 memset(ac_val2, 0, 16 * 2);
03208 if (dc_pred_dir) {
03209 if (use_pred) {
03210 memcpy(ac_val2, ac_val, 8 * 2);
03211 if (q2 && q1 != q2) {
03212 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
03213 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
03214 for (k = 1; k < 8; k++)
03215 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03216 }
03217 }
03218 } else {
03219 if (use_pred) {
03220 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
03221 if (q2 && q1 != q2) {
03222 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
03223 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
03224 for (k = 1; k < 8; k++)
03225 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03226 }
03227 }
03228 }
03229
03230
03231 if (use_pred) {
03232 if (dc_pred_dir) {
03233 for (k = 1; k < 8; k++) {
03234 block[k << v->left_blk_sh] = ac_val2[k] * scale;
03235 if (!v->pquantizer && block[k << v->left_blk_sh])
03236 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
03237 }
03238 } else {
03239 for (k = 1; k < 8; k++) {
03240 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
03241 if (!v->pquantizer && block[k << v->top_blk_sh])
03242 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
03243 }
03244 }
03245 i = 63;
03246 }
03247 }
03248 s->block_last_index[n] = i;
03249
03250 return 0;
03251 }
03252
03255 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
03256 int mquant, int ttmb, int first_block,
03257 uint8_t *dst, int linesize, int skip_block,
03258 int *ttmb_out)
03259 {
03260 MpegEncContext *s = &v->s;
03261 GetBitContext *gb = &s->gb;
03262 int i, j;
03263 int subblkpat = 0;
03264 int scale, off, idx, last, skip, value;
03265 int ttblk = ttmb & 7;
03266 int pat = 0;
03267
03268 s->dsp.clear_block(block);
03269
03270 if (ttmb == -1) {
03271 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)];
03272 }
03273 if (ttblk == TT_4X4) {
03274 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
03275 }
03276 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
03277 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
03278 || (!v->res_rtm_flag && !first_block))) {
03279 subblkpat = decode012(gb);
03280 if (subblkpat)
03281 subblkpat ^= 3;
03282 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
03283 ttblk = TT_8X4;
03284 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
03285 ttblk = TT_4X8;
03286 }
03287 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
03288
03289
03290 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
03291 subblkpat = 2 - (ttblk == TT_8X4_TOP);
03292 ttblk = TT_8X4;
03293 }
03294 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
03295 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
03296 ttblk = TT_4X8;
03297 }
03298 switch (ttblk) {
03299 case TT_8X8:
03300 pat = 0xF;
03301 i = 0;
03302 last = 0;
03303 while (!last) {
03304 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
03305 i += skip;
03306 if (i > 63)
03307 break;
03308 if (!v->fcm)
03309 idx = v->zz_8x8[0][i++];
03310 else
03311 idx = v->zzi_8x8[i++];
03312 block[idx] = value * scale;
03313 if (!v->pquantizer)
03314 block[idx] += (block[idx] < 0) ? -mquant : mquant;
03315 }
03316 if (!skip_block) {
03317 if (i == 1)
03318 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
03319 else {
03320 v->vc1dsp.vc1_inv_trans_8x8(block);
03321 s->dsp.add_pixels_clamped(block, dst, linesize);
03322 }
03323 }
03324 break;
03325 case TT_4X4:
03326 pat = ~subblkpat & 0xF;
03327 for (j = 0; j < 4; j++) {
03328 last = subblkpat & (1 << (3 - j));
03329 i = 0;
03330 off = (j & 1) * 4 + (j & 2) * 16;
03331 while (!last) {
03332 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
03333 i += skip;
03334 if (i > 15)
03335 break;
03336 if (!v->fcm)
03337 idx = ff_vc1_simple_progressive_4x4_zz[i++];
03338 else
03339 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
03340 block[idx + off] = value * scale;
03341 if (!v->pquantizer)
03342 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
03343 }
03344 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
03345 if (i == 1)
03346 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
03347 else
03348 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
03349 }
03350 }
03351 break;
03352 case TT_8X4:
03353 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
03354 for (j = 0; j < 2; j++) {
03355 last = subblkpat & (1 << (1 - j));
03356 i = 0;
03357 off = j * 32;
03358 while (!last) {
03359 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
03360 i += skip;
03361 if (i > 31)
03362 break;
03363 if (!v->fcm)
03364 idx = v->zz_8x4[i++] + off;
03365 else
03366 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
03367 block[idx] = value * scale;
03368 if (!v->pquantizer)
03369 block[idx] += (block[idx] < 0) ? -mquant : mquant;
03370 }
03371 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
03372 if (i == 1)
03373 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
03374 else
03375 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
03376 }
03377 }
03378 break;
03379 case TT_4X8:
03380 pat = ~(subblkpat * 5) & 0xF;
03381 for (j = 0; j < 2; j++) {
03382 last = subblkpat & (1 << (1 - j));
03383 i = 0;
03384 off = j * 4;
03385 while (!last) {
03386 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
03387 i += skip;
03388 if (i > 31)
03389 break;
03390 if (!v->fcm)
03391 idx = v->zz_4x8[i++] + off;
03392 else
03393 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
03394 block[idx] = value * scale;
03395 if (!v->pquantizer)
03396 block[idx] += (block[idx] < 0) ? -mquant : mquant;
03397 }
03398 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
03399 if (i == 1)
03400 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
03401 else
03402 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
03403 }
03404 }
03405 break;
03406 }
03407 if (ttmb_out)
03408 *ttmb_out |= ttblk << (n * 4);
03409 return pat;
03410 }
03411
03413
03414 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
03415 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
03416
03417 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
03418 {
03419 MpegEncContext *s = &v->s;
03420 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
03421 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
03422 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
03423 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
03424 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
03425 uint8_t *dst;
03426
03427 if (block_num > 3) {
03428 dst = s->dest[block_num - 3];
03429 } else {
03430 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
03431 }
03432 if (s->mb_y != s->end_mb_y || block_num < 2) {
03433 int16_t (*mv)[2];
03434 int mv_stride;
03435
03436 if (block_num > 3) {
03437 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
03438 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
03439 mv = &v->luma_mv[s->mb_x - s->mb_stride];
03440 mv_stride = s->mb_stride;
03441 } else {
03442 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
03443 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
03444 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
03445 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
03446 mv_stride = s->b8_stride;
03447 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
03448 }
03449
03450 if (bottom_is_intra & 1 || block_is_intra & 1 ||
03451 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
03452 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
03453 } else {
03454 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
03455 if (idx == 3) {
03456 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
03457 } else if (idx) {
03458 if (idx == 1)
03459 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
03460 else
03461 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
03462 }
03463 }
03464 }
03465
03466 dst -= 4 * linesize;
03467 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
03468 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
03469 idx = (block_cbp | (block_cbp >> 2)) & 3;
03470 if (idx == 3) {
03471 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
03472 } else if (idx) {
03473 if (idx == 1)
03474 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
03475 else
03476 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
03477 }
03478 }
03479 }
03480
03481 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
03482 {
03483 MpegEncContext *s = &v->s;
03484 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
03485 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
03486 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
03487 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
03488 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
03489 uint8_t *dst;
03490
03491 if (block_num > 3) {
03492 dst = s->dest[block_num - 3] - 8 * linesize;
03493 } else {
03494 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
03495 }
03496
03497 if (s->mb_x != s->mb_width || !(block_num & 5)) {
03498 int16_t (*mv)[2];
03499
03500 if (block_num > 3) {
03501 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
03502 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
03503 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
03504 } else {
03505 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
03506 : (mb_cbp >> ((block_num + 1) * 4));
03507 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
03508 : (mb_is_intra >> ((block_num + 1) * 4));
03509 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
03510 }
03511 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
03512 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
03513 } else {
03514 idx = ((right_cbp >> 1) | block_cbp) & 5;
03515 if (idx == 5) {
03516 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
03517 } else if (idx) {
03518 if (idx == 1)
03519 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
03520 else
03521 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
03522 }
03523 }
03524 }
03525
03526 dst -= 4;
03527 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
03528 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
03529 idx = (block_cbp | (block_cbp >> 1)) & 5;
03530 if (idx == 5) {
03531 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
03532 } else if (idx) {
03533 if (idx == 1)
03534 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
03535 else
03536 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
03537 }
03538 }
03539 }
03540
03541 static void vc1_apply_p_loop_filter(VC1Context *v)
03542 {
03543 MpegEncContext *s = &v->s;
03544 int i;
03545
03546 for (i = 0; i < 6; i++) {
03547 vc1_apply_p_v_loop_filter(v, i);
03548 }
03549
03550
03551
03552 if (s->mb_x) {
03553 for (i = 0; i < 6; i++) {
03554 vc1_apply_p_h_loop_filter(v, i);
03555 }
03556 if (s->mb_x == s->mb_width - 1) {
03557 s->mb_x++;
03558 ff_update_block_index(s);
03559 for (i = 0; i < 6; i++) {
03560 vc1_apply_p_h_loop_filter(v, i);
03561 }
03562 }
03563 }
03564 }
03565
03568 static int vc1_decode_p_mb(VC1Context *v)
03569 {
03570 MpegEncContext *s = &v->s;
03571 GetBitContext *gb = &s->gb;
03572 int i, j;
03573 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
03574 int cbp;
03575 int mqdiff, mquant;
03576 int ttmb = v->ttfrm;
03577
03578 int mb_has_coeffs = 1;
03579 int dmv_x, dmv_y;
03580 int index, index1;
03581 int val, sign;
03582 int first_block = 1;
03583 int dst_idx, off;
03584 int skipped, fourmv;
03585 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
03586
03587 mquant = v->pq;
03588
03589 if (v->mv_type_is_raw)
03590 fourmv = get_bits1(gb);
03591 else
03592 fourmv = v->mv_type_mb_plane[mb_pos];
03593 if (v->skip_is_raw)
03594 skipped = get_bits1(gb);
03595 else
03596 skipped = v->s.mbskip_table[mb_pos];
03597
03598 if (!fourmv) {
03599 if (!skipped) {
03600 GET_MVDATA(dmv_x, dmv_y);
03601
03602 if (s->mb_intra) {
03603 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
03604 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
03605 }
03606 s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
03607 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
03608
03609
03610 if (s->mb_intra && !mb_has_coeffs) {
03611 GET_MQUANT();
03612 s->ac_pred = get_bits1(gb);
03613 cbp = 0;
03614 } else if (mb_has_coeffs) {
03615 if (s->mb_intra)
03616 s->ac_pred = get_bits1(gb);
03617 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03618 GET_MQUANT();
03619 } else {
03620 mquant = v->pq;
03621 cbp = 0;
03622 }
03623 s->current_picture.f.qscale_table[mb_pos] = mquant;
03624
03625 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
03626 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
03627 VC1_TTMB_VLC_BITS, 2);
03628 if (!s->mb_intra) vc1_mc_1mv(v, 0);
03629 dst_idx = 0;
03630 for (i = 0; i < 6; i++) {
03631 s->dc_val[0][s->block_index[i]] = 0;
03632 dst_idx += i >> 2;
03633 val = ((cbp >> (5 - i)) & 1);
03634 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
03635 v->mb_type[0][s->block_index[i]] = s->mb_intra;
03636 if (s->mb_intra) {
03637
03638 v->a_avail = v->c_avail = 0;
03639 if (i == 2 || i == 3 || !s->first_slice_line)
03640 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
03641 if (i == 1 || i == 3 || s->mb_x)
03642 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
03643
03644 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
03645 (i & 4) ? v->codingset2 : v->codingset);
03646 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
03647 continue;
03648 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
03649 if (v->rangeredfrm)
03650 for (j = 0; j < 64; j++)
03651 s->block[i][j] <<= 1;
03652 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
03653 if (v->pq >= 9 && v->overlap) {
03654 if (v->c_avail)
03655 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
03656 if (v->a_avail)
03657 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
03658 }
03659 block_cbp |= 0xF << (i << 2);
03660 block_intra |= 1 << i;
03661 } else if (val) {
03662 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
03663 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
03664 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
03665 block_cbp |= pat << (i << 2);
03666 if (!v->ttmbf && ttmb < 8)
03667 ttmb = -1;
03668 first_block = 0;
03669 }
03670 }
03671 } else {
03672 s->mb_intra = 0;
03673 for (i = 0; i < 6; i++) {
03674 v->mb_type[0][s->block_index[i]] = 0;
03675 s->dc_val[0][s->block_index[i]] = 0;
03676 }
03677 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
03678 s->current_picture.f.qscale_table[mb_pos] = 0;
03679 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
03680 vc1_mc_1mv(v, 0);
03681 }
03682 } else {
03683 if (!skipped ) {
03684 int intra_count = 0, coded_inter = 0;
03685 int is_intra[6], is_coded[6];
03686
03687 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03688 for (i = 0; i < 6; i++) {
03689 val = ((cbp >> (5 - i)) & 1);
03690 s->dc_val[0][s->block_index[i]] = 0;
03691 s->mb_intra = 0;
03692 if (i < 4) {
03693 dmv_x = dmv_y = 0;
03694 s->mb_intra = 0;
03695 mb_has_coeffs = 0;
03696 if (val) {
03697 GET_MVDATA(dmv_x, dmv_y);
03698 }
03699 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
03700 if (!s->mb_intra)
03701 vc1_mc_4mv_luma(v, i, 0);
03702 intra_count += s->mb_intra;
03703 is_intra[i] = s->mb_intra;
03704 is_coded[i] = mb_has_coeffs;
03705 }
03706 if (i & 4) {
03707 is_intra[i] = (intra_count >= 3);
03708 is_coded[i] = val;
03709 }
03710 if (i == 4)
03711 vc1_mc_4mv_chroma(v, 0);
03712 v->mb_type[0][s->block_index[i]] = is_intra[i];
03713 if (!coded_inter)
03714 coded_inter = !is_intra[i] & is_coded[i];
03715 }
03716
03717 dst_idx = 0;
03718 if (!intra_count && !coded_inter)
03719 goto end;
03720 GET_MQUANT();
03721 s->current_picture.f.qscale_table[mb_pos] = mquant;
03722
03723 {
03724 int intrapred = 0;
03725 for (i = 0; i < 6; i++)
03726 if (is_intra[i]) {
03727 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
03728 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
03729 intrapred = 1;
03730 break;
03731 }
03732 }
03733 if (intrapred)
03734 s->ac_pred = get_bits1(gb);
03735 else
03736 s->ac_pred = 0;
03737 }
03738 if (!v->ttmbf && coded_inter)
03739 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
03740 for (i = 0; i < 6; i++) {
03741 dst_idx += i >> 2;
03742 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
03743 s->mb_intra = is_intra[i];
03744 if (is_intra[i]) {
03745
03746 v->a_avail = v->c_avail = 0;
03747 if (i == 2 || i == 3 || !s->first_slice_line)
03748 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
03749 if (i == 1 || i == 3 || s->mb_x)
03750 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
03751
03752 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
03753 (i & 4) ? v->codingset2 : v->codingset);
03754 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
03755 continue;
03756 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
03757 if (v->rangeredfrm)
03758 for (j = 0; j < 64; j++)
03759 s->block[i][j] <<= 1;
03760 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
03761 (i & 4) ? s->uvlinesize : s->linesize);
03762 if (v->pq >= 9 && v->overlap) {
03763 if (v->c_avail)
03764 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
03765 if (v->a_avail)
03766 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
03767 }
03768 block_cbp |= 0xF << (i << 2);
03769 block_intra |= 1 << i;
03770 } else if (is_coded[i]) {
03771 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
03772 first_block, s->dest[dst_idx] + off,
03773 (i & 4) ? s->uvlinesize : s->linesize,
03774 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
03775 &block_tt);
03776 block_cbp |= pat << (i << 2);
03777 if (!v->ttmbf && ttmb < 8)
03778 ttmb = -1;
03779 first_block = 0;
03780 }
03781 }
03782 } else {
03783 s->mb_intra = 0;
03784 s->current_picture.f.qscale_table[mb_pos] = 0;
03785 for (i = 0; i < 6; i++) {
03786 v->mb_type[0][s->block_index[i]] = 0;
03787 s->dc_val[0][s->block_index[i]] = 0;
03788 }
03789 for (i = 0; i < 4; i++) {
03790 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
03791 vc1_mc_4mv_luma(v, i, 0);
03792 }
03793 vc1_mc_4mv_chroma(v, 0);
03794 s->current_picture.f.qscale_table[mb_pos] = 0;
03795 }
03796 }
03797 end:
03798 v->cbp[s->mb_x] = block_cbp;
03799 v->ttblk[s->mb_x] = block_tt;
03800 v->is_intra[s->mb_x] = block_intra;
03801
03802 return 0;
03803 }
03804
03805
03806
03807 static int vc1_decode_p_mb_intfr(VC1Context *v)
03808 {
03809 MpegEncContext *s = &v->s;
03810 GetBitContext *gb = &s->gb;
03811 int i;
03812 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
03813 int cbp = 0;
03814 int mqdiff, mquant;
03815 int ttmb = v->ttfrm;
03816
03817 int mb_has_coeffs = 1;
03818 int dmv_x, dmv_y;
03819 int val;
03820 int first_block = 1;
03821 int dst_idx, off;
03822 int skipped, fourmv = 0, twomv = 0;
03823 int block_cbp = 0, pat, block_tt = 0;
03824 int idx_mbmode = 0, mvbp;
03825 int stride_y, fieldtx;
03826
03827 mquant = v->pq;
03828
03829 if (v->skip_is_raw)
03830 skipped = get_bits1(gb);
03831 else
03832 skipped = v->s.mbskip_table[mb_pos];
03833 if (!skipped) {
03834 if (v->fourmvswitch)
03835 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2);
03836 else
03837 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
03838 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
03839
03840 case MV_PMODE_INTFR_4MV:
03841 fourmv = 1;
03842 v->blk_mv_type[s->block_index[0]] = 0;
03843 v->blk_mv_type[s->block_index[1]] = 0;
03844 v->blk_mv_type[s->block_index[2]] = 0;
03845 v->blk_mv_type[s->block_index[3]] = 0;
03846 break;
03847 case MV_PMODE_INTFR_4MV_FIELD:
03848 fourmv = 1;
03849 v->blk_mv_type[s->block_index[0]] = 1;
03850 v->blk_mv_type[s->block_index[1]] = 1;
03851 v->blk_mv_type[s->block_index[2]] = 1;
03852 v->blk_mv_type[s->block_index[3]] = 1;
03853 break;
03854 case MV_PMODE_INTFR_2MV_FIELD:
03855 twomv = 1;
03856 v->blk_mv_type[s->block_index[0]] = 1;
03857 v->blk_mv_type[s->block_index[1]] = 1;
03858 v->blk_mv_type[s->block_index[2]] = 1;
03859 v->blk_mv_type[s->block_index[3]] = 1;
03860 break;
03861 case MV_PMODE_INTFR_1MV:
03862 v->blk_mv_type[s->block_index[0]] = 0;
03863 v->blk_mv_type[s->block_index[1]] = 0;
03864 v->blk_mv_type[s->block_index[2]] = 0;
03865 v->blk_mv_type[s->block_index[3]] = 0;
03866 break;
03867 }
03868 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) {
03869 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
03870 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
03871 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
03872 s->mb_intra = v->is_intra[s->mb_x] = 1;
03873 for (i = 0; i < 6; i++)
03874 v->mb_type[0][s->block_index[i]] = 1;
03875 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
03876 mb_has_coeffs = get_bits1(gb);
03877 if (mb_has_coeffs)
03878 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03879 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
03880 GET_MQUANT();
03881 s->current_picture.f.qscale_table[mb_pos] = mquant;
03882
03883 s->y_dc_scale = s->y_dc_scale_table[mquant];
03884 s->c_dc_scale = s->c_dc_scale_table[mquant];
03885 dst_idx = 0;
03886 for (i = 0; i < 6; i++) {
03887 s->dc_val[0][s->block_index[i]] = 0;
03888 dst_idx += i >> 2;
03889 val = ((cbp >> (5 - i)) & 1);
03890 v->mb_type[0][s->block_index[i]] = s->mb_intra;
03891 v->a_avail = v->c_avail = 0;
03892 if (i == 2 || i == 3 || !s->first_slice_line)
03893 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
03894 if (i == 1 || i == 3 || s->mb_x)
03895 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
03896
03897 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
03898 (i & 4) ? v->codingset2 : v->codingset);
03899 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
03900 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
03901 if (i < 4) {
03902 stride_y = s->linesize << fieldtx;
03903 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
03904 } else {
03905 stride_y = s->uvlinesize;
03906 off = 0;
03907 }
03908 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
03909
03910 }
03911
03912 } else {
03913 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
03914 if (mb_has_coeffs)
03915 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03916 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
03917 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
03918 } else {
03919 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
03920 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
03921 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
03922 }
03923 }
03924 s->mb_intra = v->is_intra[s->mb_x] = 0;
03925 for (i = 0; i < 6; i++)
03926 v->mb_type[0][s->block_index[i]] = 0;
03927 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
03928
03929 dst_idx = 0;
03930 if (fourmv) {
03931 mvbp = v->fourmvbp;
03932 for (i = 0; i < 6; i++) {
03933 if (i < 4) {
03934 dmv_x = dmv_y = 0;
03935 val = ((mvbp >> (3 - i)) & 1);
03936 if (val) {
03937 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
03938 }
03939 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
03940 vc1_mc_4mv_luma(v, i, 0);
03941 } else if (i == 4) {
03942 vc1_mc_4mv_chroma4(v);
03943 }
03944 }
03945 } else if (twomv) {
03946 mvbp = v->twomvbp;
03947 dmv_x = dmv_y = 0;
03948 if (mvbp & 2) {
03949 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
03950 }
03951 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
03952 vc1_mc_4mv_luma(v, 0, 0);
03953 vc1_mc_4mv_luma(v, 1, 0);
03954 dmv_x = dmv_y = 0;
03955 if (mvbp & 1) {
03956 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
03957 }
03958 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
03959 vc1_mc_4mv_luma(v, 2, 0);
03960 vc1_mc_4mv_luma(v, 3, 0);
03961 vc1_mc_4mv_chroma4(v);
03962 } else {
03963 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
03964 if (mvbp) {
03965 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
03966 }
03967 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
03968 vc1_mc_1mv(v, 0);
03969 }
03970 if (cbp)
03971 GET_MQUANT();
03972 s->current_picture.f.qscale_table[mb_pos] = mquant;
03973 if (!v->ttmbf && cbp)
03974 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
03975 for (i = 0; i < 6; i++) {
03976 s->dc_val[0][s->block_index[i]] = 0;
03977 dst_idx += i >> 2;
03978 val = ((cbp >> (5 - i)) & 1);
03979 if (!fieldtx)
03980 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
03981 else
03982 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
03983 if (val) {
03984 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
03985 first_block, s->dest[dst_idx] + off,
03986 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
03987 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
03988 block_cbp |= pat << (i << 2);
03989 if (!v->ttmbf && ttmb < 8)
03990 ttmb = -1;
03991 first_block = 0;
03992 }
03993 }
03994 }
03995 } else {
03996 s->mb_intra = v->is_intra[s->mb_x] = 0;
03997 for (i = 0; i < 6; i++) {
03998 v->mb_type[0][s->block_index[i]] = 0;
03999 s->dc_val[0][s->block_index[i]] = 0;
04000 }
04001 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
04002 s->current_picture.f.qscale_table[mb_pos] = 0;
04003 v->blk_mv_type[s->block_index[0]] = 0;
04004 v->blk_mv_type[s->block_index[1]] = 0;
04005 v->blk_mv_type[s->block_index[2]] = 0;
04006 v->blk_mv_type[s->block_index[3]] = 0;
04007 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
04008 vc1_mc_1mv(v, 0);
04009 }
04010 if (s->mb_x == s->mb_width - 1)
04011 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
04012 return 0;
04013 }
04014
04015 static int vc1_decode_p_mb_intfi(VC1Context *v)
04016 {
04017 MpegEncContext *s = &v->s;
04018 GetBitContext *gb = &s->gb;
04019 int i;
04020 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
04021 int cbp = 0;
04022 int mqdiff, mquant;
04023 int ttmb = v->ttfrm;
04024
04025 int mb_has_coeffs = 1;
04026 int dmv_x, dmv_y;
04027 int val;
04028 int first_block = 1;
04029 int dst_idx, off;
04030 int pred_flag;
04031 int block_cbp = 0, pat, block_tt = 0;
04032 int idx_mbmode = 0;
04033
04034 mquant = v->pq;
04035
04036 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
04037 if (idx_mbmode <= 1) {
04038 s->mb_intra = v->is_intra[s->mb_x] = 1;
04039 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
04040 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
04041 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
04042 GET_MQUANT();
04043 s->current_picture.f.qscale_table[mb_pos] = mquant;
04044
04045 s->y_dc_scale = s->y_dc_scale_table[mquant];
04046 s->c_dc_scale = s->c_dc_scale_table[mquant];
04047 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
04048 mb_has_coeffs = idx_mbmode & 1;
04049 if (mb_has_coeffs)
04050 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
04051 dst_idx = 0;
04052 for (i = 0; i < 6; i++) {
04053 s->dc_val[0][s->block_index[i]] = 0;
04054 v->mb_type[0][s->block_index[i]] = 1;
04055 dst_idx += i >> 2;
04056 val = ((cbp >> (5 - i)) & 1);
04057 v->a_avail = v->c_avail = 0;
04058 if (i == 2 || i == 3 || !s->first_slice_line)
04059 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
04060 if (i == 1 || i == 3 || s->mb_x)
04061 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
04062
04063 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
04064 (i & 4) ? v->codingset2 : v->codingset);
04065 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
04066 continue;
04067 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
04068 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
04069 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
04070 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
04071
04072 }
04073 } else {
04074 s->mb_intra = v->is_intra[s->mb_x] = 0;
04075 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
04076 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
04077 if (idx_mbmode <= 5) {
04078 dmv_x = dmv_y = 0;
04079 if (idx_mbmode & 1) {
04080 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
04081 }
04082 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
04083 vc1_mc_1mv(v, 0);
04084 mb_has_coeffs = !(idx_mbmode & 2);
04085 } else {
04086 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
04087 for (i = 0; i < 6; i++) {
04088 if (i < 4) {
04089 dmv_x = dmv_y = pred_flag = 0;
04090 val = ((v->fourmvbp >> (3 - i)) & 1);
04091 if (val) {
04092 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
04093 }
04094 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
04095 vc1_mc_4mv_luma(v, i, 0);
04096 } else if (i == 4)
04097 vc1_mc_4mv_chroma(v, 0);
04098 }
04099 mb_has_coeffs = idx_mbmode & 1;
04100 }
04101 if (mb_has_coeffs)
04102 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
04103 if (cbp) {
04104 GET_MQUANT();
04105 }
04106 s->current_picture.f.qscale_table[mb_pos] = mquant;
04107 if (!v->ttmbf && cbp) {
04108 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
04109 }
04110 dst_idx = 0;
04111 for (i = 0; i < 6; i++) {
04112 s->dc_val[0][s->block_index[i]] = 0;
04113 dst_idx += i >> 2;
04114 val = ((cbp >> (5 - i)) & 1);
04115 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
04116 if (v->cur_field_type)
04117 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
04118 if (val) {
04119 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
04120 first_block, s->dest[dst_idx] + off,
04121 (i & 4) ? s->uvlinesize : s->linesize,
04122 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
04123 &block_tt);
04124 block_cbp |= pat << (i << 2);
04125 if (!v->ttmbf && ttmb < 8) ttmb = -1;
04126 first_block = 0;
04127 }
04128 }
04129 }
04130 if (s->mb_x == s->mb_width - 1)
04131 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
04132 return 0;
04133 }
04134
04137 static void vc1_decode_b_mb(VC1Context *v)
04138 {
04139 MpegEncContext *s = &v->s;
04140 GetBitContext *gb = &s->gb;
04141 int i, j;
04142 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
04143 int cbp = 0;
04144 int mqdiff, mquant;
04145 int ttmb = v->ttfrm;
04146 int mb_has_coeffs = 0;
04147 int index, index1;
04148 int val, sign;
04149 int first_block = 1;
04150 int dst_idx, off;
04151 int skipped, direct;
04152 int dmv_x[2], dmv_y[2];
04153 int bmvtype = BMV_TYPE_BACKWARD;
04154
04155 mquant = v->pq;
04156 s->mb_intra = 0;
04157
04158 if (v->dmb_is_raw)
04159 direct = get_bits1(gb);
04160 else
04161 direct = v->direct_mb_plane[mb_pos];
04162 if (v->skip_is_raw)
04163 skipped = get_bits1(gb);
04164 else
04165 skipped = v->s.mbskip_table[mb_pos];
04166
04167 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
04168 for (i = 0; i < 6; i++) {
04169 v->mb_type[0][s->block_index[i]] = 0;
04170 s->dc_val[0][s->block_index[i]] = 0;
04171 }
04172 s->current_picture.f.qscale_table[mb_pos] = 0;
04173
04174 if (!direct) {
04175 if (!skipped) {
04176 GET_MVDATA(dmv_x[0], dmv_y[0]);
04177 dmv_x[1] = dmv_x[0];
04178 dmv_y[1] = dmv_y[0];
04179 }
04180 if (skipped || !s->mb_intra) {
04181 bmvtype = decode012(gb);
04182 switch (bmvtype) {
04183 case 0:
04184 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
04185 break;
04186 case 1:
04187 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
04188 break;
04189 case 2:
04190 bmvtype = BMV_TYPE_INTERPOLATED;
04191 dmv_x[0] = dmv_y[0] = 0;
04192 }
04193 }
04194 }
04195 for (i = 0; i < 6; i++)
04196 v->mb_type[0][s->block_index[i]] = s->mb_intra;
04197
04198 if (skipped) {
04199 if (direct)
04200 bmvtype = BMV_TYPE_INTERPOLATED;
04201 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04202 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
04203 return;
04204 }
04205 if (direct) {
04206 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
04207 GET_MQUANT();
04208 s->mb_intra = 0;
04209 s->current_picture.f.qscale_table[mb_pos] = mquant;
04210 if (!v->ttmbf)
04211 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
04212 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
04213 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04214 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
04215 } else {
04216 if (!mb_has_coeffs && !s->mb_intra) {
04217
04218 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04219 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
04220 return;
04221 }
04222 if (s->mb_intra && !mb_has_coeffs) {
04223 GET_MQUANT();
04224 s->current_picture.f.qscale_table[mb_pos] = mquant;
04225 s->ac_pred = get_bits1(gb);
04226 cbp = 0;
04227 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04228 } else {
04229 if (bmvtype == BMV_TYPE_INTERPOLATED) {
04230 GET_MVDATA(dmv_x[0], dmv_y[0]);
04231 if (!mb_has_coeffs) {
04232
04233 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04234 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
04235 return;
04236 }
04237 }
04238 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04239 if (!s->mb_intra) {
04240 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
04241 }
04242 if (s->mb_intra)
04243 s->ac_pred = get_bits1(gb);
04244 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
04245 GET_MQUANT();
04246 s->current_picture.f.qscale_table[mb_pos] = mquant;
04247 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
04248 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
04249 }
04250 }
04251 dst_idx = 0;
04252 for (i = 0; i < 6; i++) {
04253 s->dc_val[0][s->block_index[i]] = 0;
04254 dst_idx += i >> 2;
04255 val = ((cbp >> (5 - i)) & 1);
04256 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
04257 v->mb_type[0][s->block_index[i]] = s->mb_intra;
04258 if (s->mb_intra) {
04259
04260 v->a_avail = v->c_avail = 0;
04261 if (i == 2 || i == 3 || !s->first_slice_line)
04262 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
04263 if (i == 1 || i == 3 || s->mb_x)
04264 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
04265
04266 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
04267 (i & 4) ? v->codingset2 : v->codingset);
04268 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
04269 continue;
04270 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
04271 if (v->rangeredfrm)
04272 for (j = 0; j < 64; j++)
04273 s->block[i][j] <<= 1;
04274 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
04275 } else if (val) {
04276 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
04277 first_block, s->dest[dst_idx] + off,
04278 (i & 4) ? s->uvlinesize : s->linesize,
04279 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
04280 if (!v->ttmbf && ttmb < 8)
04281 ttmb = -1;
04282 first_block = 0;
04283 }
04284 }
04285 }
04286
04289 static void vc1_decode_b_mb_intfi(VC1Context *v)
04290 {
04291 MpegEncContext *s = &v->s;
04292 GetBitContext *gb = &s->gb;
04293 int i, j;
04294 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
04295 int cbp = 0;
04296 int mqdiff, mquant;
04297 int ttmb = v->ttfrm;
04298 int mb_has_coeffs = 0;
04299 int val;
04300 int first_block = 1;
04301 int dst_idx, off;
04302 int fwd;
04303 int dmv_x[2], dmv_y[2], pred_flag[2];
04304 int bmvtype = BMV_TYPE_BACKWARD;
04305 int idx_mbmode, interpmvp;
04306
04307 mquant = v->pq;
04308 s->mb_intra = 0;
04309
04310 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
04311 if (idx_mbmode <= 1) {
04312 s->mb_intra = v->is_intra[s->mb_x] = 1;
04313 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
04314 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
04315 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
04316 GET_MQUANT();
04317 s->current_picture.f.qscale_table[mb_pos] = mquant;
04318
04319 s->y_dc_scale = s->y_dc_scale_table[mquant];
04320 s->c_dc_scale = s->c_dc_scale_table[mquant];
04321 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
04322 mb_has_coeffs = idx_mbmode & 1;
04323 if (mb_has_coeffs)
04324 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
04325 dst_idx = 0;
04326 for (i = 0; i < 6; i++) {
04327 s->dc_val[0][s->block_index[i]] = 0;
04328 dst_idx += i >> 2;
04329 val = ((cbp >> (5 - i)) & 1);
04330 v->mb_type[0][s->block_index[i]] = s->mb_intra;
04331 v->a_avail = v->c_avail = 0;
04332 if (i == 2 || i == 3 || !s->first_slice_line)
04333 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
04334 if (i == 1 || i == 3 || s->mb_x)
04335 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
04336
04337 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
04338 (i & 4) ? v->codingset2 : v->codingset);
04339 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
04340 continue;
04341 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
04342 if (v->rangeredfrm)
04343 for (j = 0; j < 64; j++)
04344 s->block[i][j] <<= 1;
04345 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
04346 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
04347 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
04348
04349 }
04350 } else {
04351 s->mb_intra = v->is_intra[s->mb_x] = 0;
04352 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
04353 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
04354 if (v->fmb_is_raw)
04355 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
04356 else
04357 fwd = v->forward_mb_plane[mb_pos];
04358 if (idx_mbmode <= 5) {
04359 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
04360 pred_flag[0] = pred_flag[1] = 0;
04361 if (fwd)
04362 bmvtype = BMV_TYPE_FORWARD;
04363 else {
04364 bmvtype = decode012(gb);
04365 switch (bmvtype) {
04366 case 0:
04367 bmvtype = BMV_TYPE_BACKWARD;
04368 break;
04369 case 1:
04370 bmvtype = BMV_TYPE_DIRECT;
04371 break;
04372 case 2:
04373 bmvtype = BMV_TYPE_INTERPOLATED;
04374 interpmvp = get_bits1(gb);
04375 }
04376 }
04377 v->bmvtype = bmvtype;
04378 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
04379 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
04380 }
04381 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
04382 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
04383 }
04384 if (bmvtype == BMV_TYPE_DIRECT) {
04385 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
04386 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
04387 }
04388 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
04389 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
04390 mb_has_coeffs = !(idx_mbmode & 2);
04391 } else {
04392 if (fwd)
04393 bmvtype = BMV_TYPE_FORWARD;
04394 v->bmvtype = bmvtype;
04395 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
04396 for (i = 0; i < 6; i++) {
04397 if (i < 4) {
04398 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
04399 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
04400 val = ((v->fourmvbp >> (3 - i)) & 1);
04401 if (val) {
04402 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
04403 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
04404 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
04405 }
04406 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
04407 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
04408 } else if (i == 4)
04409 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
04410 }
04411 mb_has_coeffs = idx_mbmode & 1;
04412 }
04413 if (mb_has_coeffs)
04414 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
04415 if (cbp) {
04416 GET_MQUANT();
04417 }
04418 s->current_picture.f.qscale_table[mb_pos] = mquant;
04419 if (!v->ttmbf && cbp) {
04420 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
04421 }
04422 dst_idx = 0;
04423 for (i = 0; i < 6; i++) {
04424 s->dc_val[0][s->block_index[i]] = 0;
04425 dst_idx += i >> 2;
04426 val = ((cbp >> (5 - i)) & 1);
04427 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
04428 if (v->cur_field_type)
04429 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
04430 if (val) {
04431 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
04432 first_block, s->dest[dst_idx] + off,
04433 (i & 4) ? s->uvlinesize : s->linesize,
04434 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
04435 if (!v->ttmbf && ttmb < 8)
04436 ttmb = -1;
04437 first_block = 0;
04438 }
04439 }
04440 }
04441 }
04442
04445 static void vc1_decode_i_blocks(VC1Context *v)
04446 {
04447 int k, j;
04448 MpegEncContext *s = &v->s;
04449 int cbp, val;
04450 uint8_t *coded_val;
04451 int mb_pos;
04452
04453
04454 switch (v->y_ac_table_index) {
04455 case 0:
04456 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
04457 break;
04458 case 1:
04459 v->codingset = CS_HIGH_MOT_INTRA;
04460 break;
04461 case 2:
04462 v->codingset = CS_MID_RATE_INTRA;
04463 break;
04464 }
04465
04466 switch (v->c_ac_table_index) {
04467 case 0:
04468 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
04469 break;
04470 case 1:
04471 v->codingset2 = CS_HIGH_MOT_INTER;
04472 break;
04473 case 2:
04474 v->codingset2 = CS_MID_RATE_INTER;
04475 break;
04476 }
04477
04478
04479 s->y_dc_scale = s->y_dc_scale_table[v->pq];
04480 s->c_dc_scale = s->c_dc_scale_table[v->pq];
04481
04482
04483 s->mb_x = s->mb_y = 0;
04484 s->mb_intra = 1;
04485 s->first_slice_line = 1;
04486 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
04487 s->mb_x = 0;
04488 ff_init_block_index(s);
04489 for (; s->mb_x < s->mb_width; s->mb_x++) {
04490 uint8_t *dst[6];
04491 ff_update_block_index(s);
04492 dst[0] = s->dest[0];
04493 dst[1] = dst[0] + 8;
04494 dst[2] = s->dest[0] + s->linesize * 8;
04495 dst[3] = dst[2] + 8;
04496 dst[4] = s->dest[1];
04497 dst[5] = s->dest[2];
04498 s->dsp.clear_blocks(s->block[0]);
04499 mb_pos = s->mb_x + s->mb_y * s->mb_width;
04500 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
04501 s->current_picture.f.qscale_table[mb_pos] = v->pq;
04502 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
04503 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
04504
04505
04506 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
04507 v->s.ac_pred = get_bits1(&v->s.gb);
04508
04509 for (k = 0; k < 6; k++) {
04510 val = ((cbp >> (5 - k)) & 1);
04511
04512 if (k < 4) {
04513 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
04514 val = val ^ pred;
04515 *coded_val = val;
04516 }
04517 cbp |= val << (5 - k);
04518
04519 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
04520
04521 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
04522 continue;
04523 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
04524 if (v->pq >= 9 && v->overlap) {
04525 if (v->rangeredfrm)
04526 for (j = 0; j < 64; j++)
04527 s->block[k][j] <<= 1;
04528 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
04529 } else {
04530 if (v->rangeredfrm)
04531 for (j = 0; j < 64; j++)
04532 s->block[k][j] = (s->block[k][j] - 64) << 1;
04533 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
04534 }
04535 }
04536
04537 if (v->pq >= 9 && v->overlap) {
04538 if (s->mb_x) {
04539 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
04540 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
04541 if (!(s->flags & CODEC_FLAG_GRAY)) {
04542 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
04543 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
04544 }
04545 }
04546 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
04547 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
04548 if (!s->first_slice_line) {
04549 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
04550 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
04551 if (!(s->flags & CODEC_FLAG_GRAY)) {
04552 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
04553 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
04554 }
04555 }
04556 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
04557 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
04558 }
04559 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
04560
04561 if (get_bits_count(&s->gb) > v->bits) {
04562 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
04563 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
04564 get_bits_count(&s->gb), v->bits);
04565 return;
04566 }
04567 }
04568 if (!v->s.loop_filter)
04569 ff_draw_horiz_band(s, s->mb_y * 16, 16);
04570 else if (s->mb_y)
04571 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
04572
04573 s->first_slice_line = 0;
04574 }
04575 if (v->s.loop_filter)
04576 ff_draw_horiz_band(s, (s->mb_height - 1) * 16, 16);
04577 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
04578 }
04579
04582 static void vc1_decode_i_blocks_adv(VC1Context *v)
04583 {
04584 int k;
04585 MpegEncContext *s = &v->s;
04586 int cbp, val;
04587 uint8_t *coded_val;
04588 int mb_pos;
04589 int mquant = v->pq;
04590 int mqdiff;
04591 GetBitContext *gb = &s->gb;
04592
04593
04594 switch (v->y_ac_table_index) {
04595 case 0:
04596 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
04597 break;
04598 case 1:
04599 v->codingset = CS_HIGH_MOT_INTRA;
04600 break;
04601 case 2:
04602 v->codingset = CS_MID_RATE_INTRA;
04603 break;
04604 }
04605
04606 switch (v->c_ac_table_index) {
04607 case 0:
04608 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
04609 break;
04610 case 1:
04611 v->codingset2 = CS_HIGH_MOT_INTER;
04612 break;
04613 case 2:
04614 v->codingset2 = CS_MID_RATE_INTER;
04615 break;
04616 }
04617
04618
04619 s->mb_x = s->mb_y = 0;
04620 s->mb_intra = 1;
04621 s->first_slice_line = 1;
04622 s->mb_y = s->start_mb_y;
04623 if (s->start_mb_y) {
04624 s->mb_x = 0;
04625 ff_init_block_index(s);
04626 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
04627 (1 + s->b8_stride) * sizeof(*s->coded_block));
04628 }
04629 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
04630 s->mb_x = 0;
04631 ff_init_block_index(s);
04632 for (;s->mb_x < s->mb_width; s->mb_x++) {
04633 DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
04634 ff_update_block_index(s);
04635 s->dsp.clear_blocks(block[0]);
04636 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
04637 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
04638 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
04639 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
04640
04641
04642 if (v->fieldtx_is_raw)
04643 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
04644 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
04645 if ( v->acpred_is_raw)
04646 v->s.ac_pred = get_bits1(&v->s.gb);
04647 else
04648 v->s.ac_pred = v->acpred_plane[mb_pos];
04649
04650 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
04651 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
04652
04653 GET_MQUANT();
04654
04655 s->current_picture.f.qscale_table[mb_pos] = mquant;
04656
04657 s->y_dc_scale = s->y_dc_scale_table[mquant];
04658 s->c_dc_scale = s->c_dc_scale_table[mquant];
04659
04660 for (k = 0; k < 6; k++) {
04661 val = ((cbp >> (5 - k)) & 1);
04662
04663 if (k < 4) {
04664 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
04665 val = val ^ pred;
04666 *coded_val = val;
04667 }
04668 cbp |= val << (5 - k);
04669
04670 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
04671 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
04672
04673 vc1_decode_i_block_adv(v, block[k], k, val,
04674 (k < 4) ? v->codingset : v->codingset2, mquant);
04675
04676 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
04677 continue;
04678 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
04679 }
04680
04681 vc1_smooth_overlap_filter_iblk(v);
04682 vc1_put_signed_blocks_clamped(v);
04683 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
04684
04685 if (get_bits_count(&s->gb) > v->bits) {
04686
04687 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
04688 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
04689 get_bits_count(&s->gb), v->bits);
04690 return;
04691 }
04692 }
04693 if (!v->s.loop_filter)
04694 ff_draw_horiz_band(s, s->mb_y * 16, 16);
04695 else if (s->mb_y)
04696 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
04697 s->first_slice_line = 0;
04698 }
04699
04700
04701 s->mb_x = 0;
04702 ff_init_block_index(s);
04703 for (;s->mb_x < s->mb_width; s->mb_x++) {
04704 ff_update_block_index(s);
04705 vc1_put_signed_blocks_clamped(v);
04706 if (v->s.loop_filter)
04707 vc1_loop_filter_iblk_delayed(v, v->pq);
04708 }
04709 if (v->s.loop_filter)
04710 ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
04711 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
04712 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
04713 }
04714
04715 static void vc1_decode_p_blocks(VC1Context *v)
04716 {
04717 MpegEncContext *s = &v->s;
04718 int apply_loop_filter;
04719
04720
04721 switch (v->c_ac_table_index) {
04722 case 0:
04723 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
04724 break;
04725 case 1:
04726 v->codingset = CS_HIGH_MOT_INTRA;
04727 break;
04728 case 2:
04729 v->codingset = CS_MID_RATE_INTRA;
04730 break;
04731 }
04732
04733 switch (v->c_ac_table_index) {
04734 case 0:
04735 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
04736 break;
04737 case 1:
04738 v->codingset2 = CS_HIGH_MOT_INTER;
04739 break;
04740 case 2:
04741 v->codingset2 = CS_MID_RATE_INTER;
04742 break;
04743 }
04744
04745 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
04746 s->first_slice_line = 1;
04747 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
04748 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
04749 s->mb_x = 0;
04750 ff_init_block_index(s);
04751 for (; s->mb_x < s->mb_width; s->mb_x++) {
04752 ff_update_block_index(s);
04753
04754 if (v->fcm == ILACE_FIELD)
04755 vc1_decode_p_mb_intfi(v);
04756 else if (v->fcm == ILACE_FRAME)
04757 vc1_decode_p_mb_intfr(v);
04758 else vc1_decode_p_mb(v);
04759 if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == PROGRESSIVE)
04760 vc1_apply_p_loop_filter(v);
04761 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
04762
04763 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
04764 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
04765 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
04766 return;
04767 }
04768 }
04769 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
04770 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
04771 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
04772 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
04773 if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
04774 s->first_slice_line = 0;
04775 }
04776 if (apply_loop_filter) {
04777 s->mb_x = 0;
04778 ff_init_block_index(s);
04779 for (; s->mb_x < s->mb_width; s->mb_x++) {
04780 ff_update_block_index(s);
04781 vc1_apply_p_loop_filter(v);
04782 }
04783 }
04784 if (s->end_mb_y >= s->start_mb_y)
04785 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
04786 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
04787 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
04788 }
04789
04790 static void vc1_decode_b_blocks(VC1Context *v)
04791 {
04792 MpegEncContext *s = &v->s;
04793
04794
04795 switch (v->c_ac_table_index) {
04796 case 0:
04797 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
04798 break;
04799 case 1:
04800 v->codingset = CS_HIGH_MOT_INTRA;
04801 break;
04802 case 2:
04803 v->codingset = CS_MID_RATE_INTRA;
04804 break;
04805 }
04806
04807 switch (v->c_ac_table_index) {
04808 case 0:
04809 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
04810 break;
04811 case 1:
04812 v->codingset2 = CS_HIGH_MOT_INTER;
04813 break;
04814 case 2:
04815 v->codingset2 = CS_MID_RATE_INTER;
04816 break;
04817 }
04818
04819 s->first_slice_line = 1;
04820 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
04821 s->mb_x = 0;
04822 ff_init_block_index(s);
04823 for (; s->mb_x < s->mb_width; s->mb_x++) {
04824 ff_update_block_index(s);
04825
04826 if (v->fcm == ILACE_FIELD)
04827 vc1_decode_b_mb_intfi(v);
04828 else
04829 vc1_decode_b_mb(v);
04830 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
04831
04832 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
04833 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
04834 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
04835 return;
04836 }
04837 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
04838 }
04839 if (!v->s.loop_filter)
04840 ff_draw_horiz_band(s, s->mb_y * 16, 16);
04841 else if (s->mb_y)
04842 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
04843 s->first_slice_line = 0;
04844 }
04845 if (v->s.loop_filter)
04846 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
04847 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
04848 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
04849 }
04850
04851 static void vc1_decode_skip_blocks(VC1Context *v)
04852 {
04853 MpegEncContext *s = &v->s;
04854
04855 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
04856 s->first_slice_line = 1;
04857 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
04858 s->mb_x = 0;
04859 ff_init_block_index(s);
04860 ff_update_block_index(s);
04861 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
04862 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
04863 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
04864 ff_draw_horiz_band(s, s->mb_y * 16, 16);
04865 s->first_slice_line = 0;
04866 }
04867 s->pict_type = AV_PICTURE_TYPE_P;
04868 }
04869
04870 static void vc1_decode_blocks(VC1Context *v)
04871 {
04872
04873 v->s.esc3_level_length = 0;
04874 if (v->x8_type) {
04875 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
04876 } else {
04877 v->cur_blk_idx = 0;
04878 v->left_blk_idx = -1;
04879 v->topleft_blk_idx = 1;
04880 v->top_blk_idx = 2;
04881 switch (v->s.pict_type) {
04882 case AV_PICTURE_TYPE_I:
04883 if (v->profile == PROFILE_ADVANCED)
04884 vc1_decode_i_blocks_adv(v);
04885 else
04886 vc1_decode_i_blocks(v);
04887 break;
04888 case AV_PICTURE_TYPE_P:
04889 if (v->p_frame_skipped)
04890 vc1_decode_skip_blocks(v);
04891 else
04892 vc1_decode_p_blocks(v);
04893 break;
04894 case AV_PICTURE_TYPE_B:
04895 if (v->bi_type) {
04896 if (v->profile == PROFILE_ADVANCED)
04897 vc1_decode_i_blocks_adv(v);
04898 else
04899 vc1_decode_i_blocks(v);
04900 } else
04901 vc1_decode_b_blocks(v);
04902 break;
04903 }
04904 }
04905 }
04906
04907 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
04908
04909 typedef struct {
04921 int coefs[2][7];
04922
04923 int effect_type, effect_flag;
04924 int effect_pcount1, effect_pcount2;
04925 int effect_params1[15], effect_params2[10];
04926 } SpriteData;
04927
04928 static inline int get_fp_val(GetBitContext* gb)
04929 {
04930 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
04931 }
04932
04933 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
04934 {
04935 c[1] = c[3] = 0;
04936
04937 switch (get_bits(gb, 2)) {
04938 case 0:
04939 c[0] = 1 << 16;
04940 c[2] = get_fp_val(gb);
04941 c[4] = 1 << 16;
04942 break;
04943 case 1:
04944 c[0] = c[4] = get_fp_val(gb);
04945 c[2] = get_fp_val(gb);
04946 break;
04947 case 2:
04948 c[0] = get_fp_val(gb);
04949 c[2] = get_fp_val(gb);
04950 c[4] = get_fp_val(gb);
04951 break;
04952 case 3:
04953 c[0] = get_fp_val(gb);
04954 c[1] = get_fp_val(gb);
04955 c[2] = get_fp_val(gb);
04956 c[3] = get_fp_val(gb);
04957 c[4] = get_fp_val(gb);
04958 break;
04959 }
04960 c[5] = get_fp_val(gb);
04961 if (get_bits1(gb))
04962 c[6] = get_fp_val(gb);
04963 else
04964 c[6] = 1 << 16;
04965 }
04966
04967 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
04968 {
04969 AVCodecContext *avctx = v->s.avctx;
04970 int sprite, i;
04971
04972 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
04973 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
04974 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
04975 av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
04976 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
04977 for (i = 0; i < 7; i++)
04978 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
04979 sd->coefs[sprite][i] / (1<<16),
04980 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
04981 av_log(avctx, AV_LOG_DEBUG, "\n");
04982 }
04983
04984 skip_bits(gb, 2);
04985 if (sd->effect_type = get_bits_long(gb, 30)) {
04986 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
04987 case 7:
04988 vc1_sprite_parse_transform(gb, sd->effect_params1);
04989 break;
04990 case 14:
04991 vc1_sprite_parse_transform(gb, sd->effect_params1);
04992 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
04993 break;
04994 default:
04995 for (i = 0; i < sd->effect_pcount1; i++)
04996 sd->effect_params1[i] = get_fp_val(gb);
04997 }
04998 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
04999
05000 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
05001 for (i = 0; i < sd->effect_pcount1; i++)
05002 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
05003 sd->effect_params1[i] / (1 << 16),
05004 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
05005 av_log(avctx, AV_LOG_DEBUG, "\n");
05006 }
05007
05008 sd->effect_pcount2 = get_bits(gb, 16);
05009 if (sd->effect_pcount2 > 10) {
05010 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
05011 return;
05012 } else if (sd->effect_pcount2) {
05013 i = -1;
05014 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
05015 while (++i < sd->effect_pcount2) {
05016 sd->effect_params2[i] = get_fp_val(gb);
05017 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
05018 sd->effect_params2[i] / (1 << 16),
05019 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
05020 }
05021 av_log(avctx, AV_LOG_DEBUG, "\n");
05022 }
05023 }
05024 if (sd->effect_flag = get_bits1(gb))
05025 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
05026
05027 if (get_bits_count(gb) >= gb->size_in_bits +
05028 (avctx->codec_id == CODEC_ID_WMV3IMAGE ? 64 : 0))
05029 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
05030 if (get_bits_count(gb) < gb->size_in_bits - 8)
05031 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
05032 }
05033
05034 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
05035 {
05036 int i, plane, row, sprite;
05037 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
05038 uint8_t* src_h[2][2];
05039 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
05040 int ysub[2];
05041 MpegEncContext *s = &v->s;
05042
05043 for (i = 0; i < 2; i++) {
05044 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
05045 xadv[i] = sd->coefs[i][0];
05046 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
05047 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
05048
05049 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
05050 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
05051 }
05052 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
05053
05054 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
05055 int width = v->output_width>>!!plane;
05056
05057 for (row = 0; row < v->output_height>>!!plane; row++) {
05058 uint8_t *dst = v->sprite_output_frame.data[plane] +
05059 v->sprite_output_frame.linesize[plane] * row;
05060
05061 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
05062 uint8_t *iplane = s->current_picture.f.data[plane];
05063 int iline = s->current_picture.f.linesize[plane];
05064 int ycoord = yoff[sprite] + yadv[sprite] * row;
05065 int yline = ycoord >> 16;
05066 ysub[sprite] = ycoord & 0xFFFF;
05067 if (sprite) {
05068 iplane = s->last_picture.f.data[plane];
05069 iline = s->last_picture.f.linesize[plane];
05070 }
05071 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
05072 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
05073 if (ysub[sprite])
05074 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + (yline + 1) * iline;
05075 } else {
05076 if (sr_cache[sprite][0] != yline) {
05077 if (sr_cache[sprite][1] == yline) {
05078 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
05079 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
05080 } else {
05081 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
05082 sr_cache[sprite][0] = yline;
05083 }
05084 }
05085 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
05086 v->vc1dsp.sprite_h(v->sr_rows[sprite][1], iplane + (yline + 1) * iline, xoff[sprite], xadv[sprite], width);
05087 sr_cache[sprite][1] = yline + 1;
05088 }
05089 src_h[sprite][0] = v->sr_rows[sprite][0];
05090 src_h[sprite][1] = v->sr_rows[sprite][1];
05091 }
05092 }
05093
05094 if (!v->two_sprites) {
05095 if (ysub[0]) {
05096 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
05097 } else {
05098 memcpy(dst, src_h[0][0], width);
05099 }
05100 } else {
05101 if (ysub[0] && ysub[1]) {
05102 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
05103 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
05104 } else if (ysub[0]) {
05105 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
05106 src_h[1][0], alpha, width);
05107 } else if (ysub[1]) {
05108 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
05109 src_h[0][0], (1<<16)-1-alpha, width);
05110 } else {
05111 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
05112 }
05113 }
05114 }
05115
05116 if (!plane) {
05117 for (i = 0; i < 2; i++) {
05118 xoff[i] >>= 1;
05119 yoff[i] >>= 1;
05120 }
05121 }
05122
05123 }
05124 }
05125
05126
05127 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
05128 {
05129 MpegEncContext *s = &v->s;
05130 AVCodecContext *avctx = s->avctx;
05131 SpriteData sd;
05132
05133 vc1_parse_sprites(v, gb, &sd);
05134
05135 if (!s->current_picture.f.data[0]) {
05136 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
05137 return -1;
05138 }
05139
05140 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
05141 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
05142 v->two_sprites = 0;
05143 }
05144
05145 if (v->sprite_output_frame.data[0])
05146 avctx->release_buffer(avctx, &v->sprite_output_frame);
05147
05148 v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
05149 v->sprite_output_frame.reference = 0;
05150 if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
05151 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
05152 return -1;
05153 }
05154
05155 vc1_draw_sprites(v, &sd);
05156
05157 return 0;
05158 }
05159
05160 static void vc1_sprite_flush(AVCodecContext *avctx)
05161 {
05162 VC1Context *v = avctx->priv_data;
05163 MpegEncContext *s = &v->s;
05164 AVFrame *f = &s->current_picture.f;
05165 int plane, i;
05166
05167
05168
05169
05170
05171 if (f->data[0])
05172 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
05173 for (i = 0; i < v->sprite_height>>!!plane; i++)
05174 memset(f->data[plane] + i * f->linesize[plane],
05175 plane ? 128 : 0, f->linesize[plane]);
05176 }
05177
05178 #endif
05179
05180 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
05181 {
05182 MpegEncContext *s = &v->s;
05183 int i;
05184
05185
05186 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
05187 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
05188 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
05189 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
05190 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
05191 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
05192
05193 v->n_allocated_blks = s->mb_width + 2;
05194 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
05195 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
05196 v->cbp = v->cbp_base + s->mb_stride;
05197 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
05198 v->ttblk = v->ttblk_base + s->mb_stride;
05199 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
05200 v->is_intra = v->is_intra_base + s->mb_stride;
05201 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
05202 v->luma_mv = v->luma_mv_base + s->mb_stride;
05203
05204
05205 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05206 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
05207 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
05208 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
05209
05210
05211 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05212 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
05213 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05214 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
05215 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05216 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05217 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
05218 v->mv_f_last[1] = v->mv_f_last[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05219 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05220 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
05221 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05222
05223
05224 if (v->profile == PROFILE_ADVANCED) {
05225
05226
05227
05228
05229 }
05230
05231 ff_intrax8_common_init(&v->x8,s);
05232
05233 if (s->avctx->codec_id == CODEC_ID_WMV3IMAGE || s->avctx->codec_id == CODEC_ID_VC1IMAGE) {
05234 for (i = 0; i < 4; i++)
05235 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
05236 }
05237
05238 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
05239 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
05240 !v->mb_type_base)
05241 return -1;
05242
05243 return 0;
05244 }
05245
05250 static av_cold int vc1_decode_init(AVCodecContext *avctx)
05251 {
05252 VC1Context *v = avctx->priv_data;
05253 MpegEncContext *s = &v->s;
05254 GetBitContext gb;
05255 int i;
05256
05257
05258 v->output_width = avctx->width;
05259 v->output_height = avctx->height;
05260
05261 if (!avctx->extradata_size || !avctx->extradata)
05262 return -1;
05263 if (!(avctx->flags & CODEC_FLAG_GRAY))
05264 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
05265 else
05266 avctx->pix_fmt = PIX_FMT_GRAY8;
05267 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
05268 v->s.avctx = avctx;
05269 avctx->flags |= CODEC_FLAG_EMU_EDGE;
05270 v->s.flags |= CODEC_FLAG_EMU_EDGE;
05271
05272 if (avctx->idct_algo == FF_IDCT_AUTO) {
05273 avctx->idct_algo = FF_IDCT_WMV2;
05274 }
05275
05276 if (ff_vc1_init_common(v) < 0)
05277 return -1;
05278 ff_vc1dsp_init(&v->vc1dsp);
05279
05280 if (avctx->codec_id == CODEC_ID_WMV3 || avctx->codec_id == CODEC_ID_WMV3IMAGE) {
05281 int count = 0;
05282
05283
05284
05285
05286
05287
05288 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
05289
05290 if (vc1_decode_sequence_header(avctx, v, &gb) < 0)
05291 return -1;
05292
05293 count = avctx->extradata_size*8 - get_bits_count(&gb);
05294 if (count > 0) {
05295 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
05296 count, get_bits(&gb, count));
05297 } else if (count < 0) {
05298 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
05299 }
05300 } else {
05301 const uint8_t *start = avctx->extradata;
05302 uint8_t *end = avctx->extradata + avctx->extradata_size;
05303 const uint8_t *next;
05304 int size, buf2_size;
05305 uint8_t *buf2 = NULL;
05306 int seq_initialized = 0, ep_initialized = 0;
05307
05308 if (avctx->extradata_size < 16) {
05309 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
05310 return -1;
05311 }
05312
05313 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
05314 start = find_next_marker(start, end);
05315 next = start;
05316 for (; next < end; start = next) {
05317 next = find_next_marker(start + 4, end);
05318 size = next - start - 4;
05319 if (size <= 0)
05320 continue;
05321 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
05322 init_get_bits(&gb, buf2, buf2_size * 8);
05323 switch (AV_RB32(start)) {
05324 case VC1_CODE_SEQHDR:
05325 if (vc1_decode_sequence_header(avctx, v, &gb) < 0) {
05326 av_free(buf2);
05327 return -1;
05328 }
05329 seq_initialized = 1;
05330 break;
05331 case VC1_CODE_ENTRYPOINT:
05332 if (vc1_decode_entry_point(avctx, v, &gb) < 0) {
05333 av_free(buf2);
05334 return -1;
05335 }
05336 ep_initialized = 1;
05337 break;
05338 }
05339 }
05340 av_free(buf2);
05341 if (!seq_initialized || !ep_initialized) {
05342 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
05343 return -1;
05344 }
05345 v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
05346 }
05347
05348 avctx->profile = v->profile;
05349 if (v->profile == PROFILE_ADVANCED)
05350 avctx->level = v->level;
05351
05352 avctx->has_b_frames = !!avctx->max_b_frames;
05353
05354 s->mb_width = (avctx->coded_width + 15) >> 4;
05355 s->mb_height = (avctx->coded_height + 15) >> 4;
05356
05357 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
05358 for (i = 0; i < 64; i++) {
05359 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
05360 v->zz_8x8[0][i] = transpose(wmv1_scantable[0][i]);
05361 v->zz_8x8[1][i] = transpose(wmv1_scantable[1][i]);
05362 v->zz_8x8[2][i] = transpose(wmv1_scantable[2][i]);
05363 v->zz_8x8[3][i] = transpose(wmv1_scantable[3][i]);
05364 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
05365 }
05366 v->left_blk_sh = 0;
05367 v->top_blk_sh = 3;
05368 } else {
05369 memcpy(v->zz_8x8, wmv1_scantable, 4*64);
05370 v->left_blk_sh = 3;
05371 v->top_blk_sh = 0;
05372 }
05373
05374 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05375 v->sprite_width = avctx->coded_width;
05376 v->sprite_height = avctx->coded_height;
05377
05378 avctx->coded_width = avctx->width = v->output_width;
05379 avctx->coded_height = avctx->height = v->output_height;
05380
05381
05382 if (v->sprite_width > 1 << 14 ||
05383 v->sprite_height > 1 << 14 ||
05384 v->output_width > 1 << 14 ||
05385 v->output_height > 1 << 14) return -1;
05386 }
05387 return 0;
05388 }
05389
05393 static av_cold int vc1_decode_end(AVCodecContext *avctx)
05394 {
05395 VC1Context *v = avctx->priv_data;
05396 int i;
05397
05398 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
05399 && v->sprite_output_frame.data[0])
05400 avctx->release_buffer(avctx, &v->sprite_output_frame);
05401 for (i = 0; i < 4; i++)
05402 av_freep(&v->sr_rows[i >> 1][i & 1]);
05403 av_freep(&v->hrd_rate);
05404 av_freep(&v->hrd_buffer);
05405 MPV_common_end(&v->s);
05406 av_freep(&v->mv_type_mb_plane);
05407 av_freep(&v->direct_mb_plane);
05408 av_freep(&v->forward_mb_plane);
05409 av_freep(&v->fieldtx_plane);
05410 av_freep(&v->acpred_plane);
05411 av_freep(&v->over_flags_plane);
05412 av_freep(&v->mb_type_base);
05413 av_freep(&v->blk_mv_type_base);
05414 av_freep(&v->mv_f_base);
05415 av_freep(&v->mv_f_last_base);
05416 av_freep(&v->mv_f_next_base);
05417 av_freep(&v->block);
05418 av_freep(&v->cbp_base);
05419 av_freep(&v->ttblk_base);
05420 av_freep(&v->is_intra_base);
05421 av_freep(&v->luma_mv_base);
05422 ff_intrax8_common_end(&v->x8);
05423 return 0;
05424 }
05425
05426
05430 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
05431 int *data_size, AVPacket *avpkt)
05432 {
05433 const uint8_t *buf = avpkt->data;
05434 int buf_size = avpkt->size, n_slices = 0, i;
05435 VC1Context *v = avctx->priv_data;
05436 MpegEncContext *s = &v->s;
05437 AVFrame *pict = data;
05438 uint8_t *buf2 = NULL;
05439 const uint8_t *buf_start = buf;
05440 int mb_height, n_slices1;
05441 struct {
05442 uint8_t *buf;
05443 GetBitContext gb;
05444 int mby_start;
05445 } *slices = NULL, *tmp;
05446
05447
05448 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
05449
05450 if (s->low_delay == 0 && s->next_picture_ptr) {
05451 *pict = *(AVFrame*)s->next_picture_ptr;
05452 s->next_picture_ptr = NULL;
05453
05454 *data_size = sizeof(AVFrame);
05455 }
05456
05457 return 0;
05458 }
05459
05460 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
05461 if (v->profile < PROFILE_ADVANCED)
05462 avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
05463 else
05464 avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
05465 }
05466
05467
05468 if (avctx->codec_id == CODEC_ID_VC1 || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05469 int buf_size2 = 0;
05470 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05471
05472 if (IS_MARKER(AV_RB32(buf))) {
05473 const uint8_t *start, *end, *next;
05474 int size;
05475
05476 next = buf;
05477 for (start = buf, end = buf + buf_size; next < end; start = next) {
05478 next = find_next_marker(start + 4, end);
05479 size = next - start - 4;
05480 if (size <= 0) continue;
05481 switch (AV_RB32(start)) {
05482 case VC1_CODE_FRAME:
05483 if (avctx->hwaccel ||
05484 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
05485 buf_start = start;
05486 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
05487 break;
05488 case VC1_CODE_FIELD: {
05489 int buf_size3;
05490 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
05491 if (!slices)
05492 goto err;
05493 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05494 if (!slices[n_slices].buf)
05495 goto err;
05496 buf_size3 = vc1_unescape_buffer(start + 4, size,
05497 slices[n_slices].buf);
05498 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
05499 buf_size3 << 3);
05500
05501
05502 slices[n_slices].mby_start = s->mb_height >> 1;
05503 n_slices1 = n_slices - 1;
05504 n_slices++;
05505 break;
05506 }
05507 case VC1_CODE_ENTRYPOINT:
05508 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
05509 init_get_bits(&s->gb, buf2, buf_size2 * 8);
05510 vc1_decode_entry_point(avctx, v, &s->gb);
05511 break;
05512 case VC1_CODE_SLICE: {
05513 int buf_size3;
05514 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
05515 if (!slices)
05516 goto err;
05517 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05518 if (!slices[n_slices].buf)
05519 goto err;
05520 buf_size3 = vc1_unescape_buffer(start + 4, size,
05521 slices[n_slices].buf);
05522 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
05523 buf_size3 << 3);
05524 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
05525 n_slices++;
05526 break;
05527 }
05528 }
05529 }
05530 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) {
05531 const uint8_t *divider;
05532 int buf_size3;
05533
05534 divider = find_next_marker(buf, buf + buf_size);
05535 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
05536 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
05537 goto err;
05538 } else {
05539 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
05540 if (!tmp)
05541 goto err;
05542 slices = tmp;
05543 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05544 if (!slices[n_slices].buf)
05545 goto err;
05546 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
05547 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
05548 buf_size3 << 3);
05549 slices[n_slices].mby_start = s->mb_height >> 1;
05550 n_slices1 = n_slices - 1;
05551 n_slices++;
05552 }
05553 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
05554 } else {
05555 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
05556 }
05557 init_get_bits(&s->gb, buf2, buf_size2*8);
05558 } else
05559 init_get_bits(&s->gb, buf, buf_size*8);
05560
05561 if (v->res_sprite) {
05562 v->new_sprite = !get_bits1(&s->gb);
05563 v->two_sprites = get_bits1(&s->gb);
05564
05565
05566
05567
05568 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05569 if (v->new_sprite) {
05570
05571 avctx->width = avctx->coded_width = v->sprite_width;
05572 avctx->height = avctx->coded_height = v->sprite_height;
05573 } else {
05574 goto image;
05575 }
05576 }
05577 }
05578
05579 if (s->context_initialized &&
05580 (s->width != avctx->coded_width ||
05581 s->height != avctx->coded_height)) {
05582 vc1_decode_end(avctx);
05583 }
05584
05585 if (!s->context_initialized) {
05586 if (ff_msmpeg4_decode_init(avctx) < 0 || vc1_decode_init_alloc_tables(v) < 0)
05587 return -1;
05588
05589 s->low_delay = !avctx->has_b_frames || v->res_sprite;
05590
05591 if (v->profile == PROFILE_ADVANCED) {
05592 s->h_edge_pos = avctx->coded_width;
05593 s->v_edge_pos = avctx->coded_height;
05594 }
05595 }
05596
05597
05598
05599 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
05600 int i = ff_find_unused_picture(s, 0);
05601 if (i < 0)
05602 goto err;
05603 s->current_picture_ptr = &s->picture[i];
05604 }
05605
05606
05607 v->pic_header_flag = 0;
05608 if (v->profile < PROFILE_ADVANCED) {
05609 if (vc1_parse_frame_header(v, &s->gb) == -1) {
05610 goto err;
05611 }
05612 } else {
05613 if (vc1_parse_frame_header_adv(v, &s->gb) == -1) {
05614 goto err;
05615 }
05616 }
05617
05618 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
05619 && s->pict_type != AV_PICTURE_TYPE_I) {
05620 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
05621 goto err;
05622 }
05623
05624
05625 s->current_picture_ptr->f.repeat_pict = 0;
05626
05627
05628 if (v->rff) {
05629
05630 s->current_picture_ptr->f.repeat_pict = 1;
05631 } else if (v->rptfrm) {
05632
05633 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
05634 }
05635
05636
05637 s->current_picture.f.pict_type = s->pict_type;
05638 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
05639
05640
05641 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
05642 goto err;
05643 }
05644 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
05645 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
05646 avctx->skip_frame >= AVDISCARD_ALL) {
05647 goto end;
05648 }
05649
05650 if (s->next_p_frame_damaged) {
05651 if (s->pict_type == AV_PICTURE_TYPE_B)
05652 goto end;
05653 else
05654 s->next_p_frame_damaged = 0;
05655 }
05656
05657 if (MPV_frame_start(s, avctx) < 0) {
05658 goto err;
05659 }
05660
05661 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
05662 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
05663
05664 if ((CONFIG_VC1_VDPAU_DECODER)
05665 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
05666 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
05667 else if (avctx->hwaccel) {
05668 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
05669 goto err;
05670 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
05671 goto err;
05672 if (avctx->hwaccel->end_frame(avctx) < 0)
05673 goto err;
05674 } else {
05675 ff_er_frame_start(s);
05676
05677 v->bits = buf_size * 8;
05678 if (v->field_mode) {
05679 uint8_t *tmp[2];
05680 s->current_picture.f.linesize[0] <<= 1;
05681 s->current_picture.f.linesize[1] <<= 1;
05682 s->current_picture.f.linesize[2] <<= 1;
05683 s->linesize <<= 1;
05684 s->uvlinesize <<= 1;
05685 tmp[0] = v->mv_f_last[0];
05686 tmp[1] = v->mv_f_last[1];
05687 v->mv_f_last[0] = v->mv_f_next[0];
05688 v->mv_f_last[1] = v->mv_f_next[1];
05689 v->mv_f_next[0] = v->mv_f[0];
05690 v->mv_f_next[1] = v->mv_f[1];
05691 v->mv_f[0] = tmp[0];
05692 v->mv_f[1] = tmp[1];
05693 }
05694 mb_height = s->mb_height >> v->field_mode;
05695 for (i = 0; i <= n_slices; i++) {
05696 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
05697 v->second_field = 1;
05698 v->blocks_off = s->mb_width * s->mb_height << 1;
05699 v->mb_off = s->mb_stride * s->mb_height >> 1;
05700 } else {
05701 v->second_field = 0;
05702 v->blocks_off = 0;
05703 v->mb_off = 0;
05704 }
05705 if (i) {
05706 v->pic_header_flag = 0;
05707 if (v->field_mode && i == n_slices1 + 2)
05708 vc1_parse_frame_header_adv(v, &s->gb);
05709 else if (get_bits1(&s->gb)) {
05710 v->pic_header_flag = 1;
05711 vc1_parse_frame_header_adv(v, &s->gb);
05712 }
05713 }
05714 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
05715 if (!v->field_mode || v->second_field)
05716 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
05717 else
05718 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
05719 vc1_decode_blocks(v);
05720 if (i != n_slices)
05721 s->gb = slices[i].gb;
05722 }
05723 if (v->field_mode) {
05724 v->second_field = 0;
05725 if (s->pict_type == AV_PICTURE_TYPE_B) {
05726 memcpy(v->mv_f_base, v->mv_f_next_base,
05727 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05728 }
05729 s->current_picture.f.linesize[0] >>= 1;
05730 s->current_picture.f.linesize[1] >>= 1;
05731 s->current_picture.f.linesize[2] >>= 1;
05732 s->linesize >>= 1;
05733 s->uvlinesize >>= 1;
05734 }
05735
05736
05737
05738 ff_er_frame_end(s);
05739 }
05740
05741 MPV_frame_end(s);
05742
05743 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05744 image:
05745 avctx->width = avctx->coded_width = v->output_width;
05746 avctx->height = avctx->coded_height = v->output_height;
05747 if (avctx->skip_frame >= AVDISCARD_NONREF)
05748 goto end;
05749 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
05750 if (vc1_decode_sprites(v, &s->gb))
05751 goto err;
05752 #endif
05753 *pict = v->sprite_output_frame;
05754 *data_size = sizeof(AVFrame);
05755 } else {
05756 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
05757 *pict = *(AVFrame*)s->current_picture_ptr;
05758 } else if (s->last_picture_ptr != NULL) {
05759 *pict = *(AVFrame*)s->last_picture_ptr;
05760 }
05761 if (s->last_picture_ptr || s->low_delay) {
05762 *data_size = sizeof(AVFrame);
05763 ff_print_debug_info(s, pict);
05764 }
05765 }
05766
05767 end:
05768 av_free(buf2);
05769 for (i = 0; i < n_slices; i++)
05770 av_free(slices[i].buf);
05771 av_free(slices);
05772 return buf_size;
05773
05774 err:
05775 av_free(buf2);
05776 for (i = 0; i < n_slices; i++)
05777 av_free(slices[i].buf);
05778 av_free(slices);
05779 return -1;
05780 }
05781
05782
05783 static const AVProfile profiles[] = {
05784 { FF_PROFILE_VC1_SIMPLE, "Simple" },
05785 { FF_PROFILE_VC1_MAIN, "Main" },
05786 { FF_PROFILE_VC1_COMPLEX, "Complex" },
05787 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
05788 { FF_PROFILE_UNKNOWN },
05789 };
05790
05791 AVCodec ff_vc1_decoder = {
05792 .name = "vc1",
05793 .type = AVMEDIA_TYPE_VIDEO,
05794 .id = CODEC_ID_VC1,
05795 .priv_data_size = sizeof(VC1Context),
05796 .init = vc1_decode_init,
05797 .close = vc1_decode_end,
05798 .decode = vc1_decode_frame,
05799 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
05800 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
05801 .pix_fmts = ff_hwaccel_pixfmt_list_420,
05802 .profiles = NULL_IF_CONFIG_SMALL(profiles)
05803 };
05804
05805 #if CONFIG_WMV3_DECODER
05806 AVCodec ff_wmv3_decoder = {
05807 .name = "wmv3",
05808 .type = AVMEDIA_TYPE_VIDEO,
05809 .id = CODEC_ID_WMV3,
05810 .priv_data_size = sizeof(VC1Context),
05811 .init = vc1_decode_init,
05812 .close = vc1_decode_end,
05813 .decode = vc1_decode_frame,
05814 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
05815 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
05816 .pix_fmts = ff_hwaccel_pixfmt_list_420,
05817 .profiles = NULL_IF_CONFIG_SMALL(profiles)
05818 };
05819 #endif
05820
05821 #if CONFIG_WMV3_VDPAU_DECODER
05822 AVCodec ff_wmv3_vdpau_decoder = {
05823 .name = "wmv3_vdpau",
05824 .type = AVMEDIA_TYPE_VIDEO,
05825 .id = CODEC_ID_WMV3,
05826 .priv_data_size = sizeof(VC1Context),
05827 .init = vc1_decode_init,
05828 .close = vc1_decode_end,
05829 .decode = vc1_decode_frame,
05830 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
05831 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
05832 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE},
05833 .profiles = NULL_IF_CONFIG_SMALL(profiles)
05834 };
05835 #endif
05836
05837 #if CONFIG_VC1_VDPAU_DECODER
05838 AVCodec ff_vc1_vdpau_decoder = {
05839 .name = "vc1_vdpau",
05840 .type = AVMEDIA_TYPE_VIDEO,
05841 .id = CODEC_ID_VC1,
05842 .priv_data_size = sizeof(VC1Context),
05843 .init = vc1_decode_init,
05844 .close = vc1_decode_end,
05845 .decode = vc1_decode_frame,
05846 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
05847 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
05848 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE},
05849 .profiles = NULL_IF_CONFIG_SMALL(profiles)
05850 };
05851 #endif
05852
05853 #if CONFIG_WMV3IMAGE_DECODER
05854 AVCodec ff_wmv3image_decoder = {
05855 .name = "wmv3image",
05856 .type = AVMEDIA_TYPE_VIDEO,
05857 .id = CODEC_ID_WMV3IMAGE,
05858 .priv_data_size = sizeof(VC1Context),
05859 .init = vc1_decode_init,
05860 .close = vc1_decode_end,
05861 .decode = vc1_decode_frame,
05862 .capabilities = CODEC_CAP_DR1,
05863 .flush = vc1_sprite_flush,
05864 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
05865 .pix_fmts = ff_pixfmt_list_420
05866 };
05867 #endif
05868
05869 #if CONFIG_VC1IMAGE_DECODER
05870 AVCodec ff_vc1image_decoder = {
05871 .name = "vc1image",
05872 .type = AVMEDIA_TYPE_VIDEO,
05873 .id = CODEC_ID_VC1IMAGE,
05874 .priv_data_size = sizeof(VC1Context),
05875 .init = vc1_decode_init,
05876 .close = vc1_decode_end,
05877 .decode = vc1_decode_frame,
05878 .capabilities = CODEC_CAP_DR1,
05879 .flush = vc1_sprite_flush,
05880 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
05881 .pix_fmts = ff_pixfmt_list_420
05882 };
05883 #endif