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