2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
32 #include "mpegvideo.h"
36 #include "vc1acdata.h"
37 #include "msmpeg4data.h"
39 #include "simple_idct.h"
41 #include "vdpau_internal.h"
42 #include "libavutil/avassert.h"
47 #define MB_INTRA_VLC_BITS 9
51 // offset tables for interlaced picture MVDATA decoding
52 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
53 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
55 /***********************************************************************/
57 * @name VC-1 Bitplane decoding
75 /** @} */ //imode defines
78 /** @} */ //Bitplane group
80 static void vc1_put_signed_blocks_clamped(VC1Context *v)
82 MpegEncContext *s = &v->s;
83 int topleft_mb_pos, top_mb_pos;
84 int stride_y, fieldtx;
87 /* The put pixels loop is always one MB row behind the decoding loop,
88 * because we can only put pixels when overlap filtering is done, and
89 * for filtering of the bottom edge of a MB, we need the next MB row
91 * Within the row, the put pixels loop is also one MB col behind the
92 * decoding loop. The reason for this is again, because for filtering
93 * of the right MB edge, we need the next MB present. */
94 if (!s->first_slice_line) {
96 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
97 fieldtx = v->fieldtx_plane[topleft_mb_pos];
98 stride_y = s->linesize << fieldtx;
99 v_dist = (16 - fieldtx) >> (fieldtx == 0);
100 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
101 s->dest[0] - 16 * s->linesize - 16,
103 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
104 s->dest[0] - 16 * s->linesize - 8,
106 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
107 s->dest[0] - v_dist * s->linesize - 16,
109 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
110 s->dest[0] - v_dist * s->linesize - 8,
112 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
113 s->dest[1] - 8 * s->uvlinesize - 8,
115 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
116 s->dest[2] - 8 * s->uvlinesize - 8,
119 if (s->mb_x == s->mb_width - 1) {
120 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
121 fieldtx = v->fieldtx_plane[top_mb_pos];
122 stride_y = s->linesize << fieldtx;
123 v_dist = fieldtx ? 15 : 8;
124 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
125 s->dest[0] - 16 * s->linesize,
127 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
128 s->dest[0] - 16 * s->linesize + 8,
130 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
131 s->dest[0] - v_dist * s->linesize,
133 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
134 s->dest[0] - v_dist * s->linesize + 8,
136 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
137 s->dest[1] - 8 * s->uvlinesize,
139 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
140 s->dest[2] - 8 * s->uvlinesize,
145 #define inc_blk_idx(idx) do { \
147 if (idx >= v->n_allocated_blks) \
151 inc_blk_idx(v->topleft_blk_idx);
152 inc_blk_idx(v->top_blk_idx);
153 inc_blk_idx(v->left_blk_idx);
154 inc_blk_idx(v->cur_blk_idx);
157 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
159 MpegEncContext *s = &v->s;
161 if (!s->first_slice_line) {
162 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
164 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
165 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
166 for (j = 0; j < 2; j++) {
167 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
169 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
172 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
174 if (s->mb_y == s->end_mb_y - 1) {
176 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
177 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
178 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
180 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
184 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
186 MpegEncContext *s = &v->s;
189 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
190 * means it runs two rows/cols behind the decoding loop. */
191 if (!s->first_slice_line) {
193 if (s->mb_y >= s->start_mb_y + 2) {
194 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
197 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
198 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
199 for (j = 0; j < 2; j++) {
200 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
202 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
206 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
209 if (s->mb_x == s->mb_width - 1) {
210 if (s->mb_y >= s->start_mb_y + 2) {
211 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
214 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
215 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
216 for (j = 0; j < 2; j++) {
217 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
219 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
223 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
226 if (s->mb_y == s->end_mb_y) {
229 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
230 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
232 for (j = 0; j < 2; j++) {
233 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
238 if (s->mb_x == s->mb_width - 1) {
240 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
241 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
243 for (j = 0; j < 2; j++) {
244 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
252 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
254 MpegEncContext *s = &v->s;
257 if (v->condover == CONDOVER_NONE)
260 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
262 /* Within a MB, the horizontal overlap always runs before the vertical.
263 * To accomplish that, we run the H on left and internal borders of the
264 * currently decoded MB. Then, we wait for the next overlap iteration
265 * to do H overlap on the right edge of this MB, before moving over and
266 * running the V overlap. Therefore, the V overlap makes us trail by one
267 * MB col and the H overlap filter makes us trail by one MB row. This
268 * is reflected in the time at which we run the put_pixels loop. */
269 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
270 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
271 v->over_flags_plane[mb_pos - 1])) {
272 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
273 v->block[v->cur_blk_idx][0]);
274 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
275 v->block[v->cur_blk_idx][2]);
276 if (!(s->flags & CODEC_FLAG_GRAY)) {
277 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
278 v->block[v->cur_blk_idx][4]);
279 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
280 v->block[v->cur_blk_idx][5]);
283 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
284 v->block[v->cur_blk_idx][1]);
285 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
286 v->block[v->cur_blk_idx][3]);
288 if (s->mb_x == s->mb_width - 1) {
289 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
290 v->over_flags_plane[mb_pos - s->mb_stride])) {
291 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
292 v->block[v->cur_blk_idx][0]);
293 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
294 v->block[v->cur_blk_idx][1]);
295 if (!(s->flags & CODEC_FLAG_GRAY)) {
296 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
297 v->block[v->cur_blk_idx][4]);
298 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
299 v->block[v->cur_blk_idx][5]);
302 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
303 v->block[v->cur_blk_idx][2]);
304 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
305 v->block[v->cur_blk_idx][3]);
308 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
309 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
310 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
311 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
312 v->block[v->left_blk_idx][0]);
313 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
314 v->block[v->left_blk_idx][1]);
315 if (!(s->flags & CODEC_FLAG_GRAY)) {
316 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
317 v->block[v->left_blk_idx][4]);
318 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
319 v->block[v->left_blk_idx][5]);
322 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
323 v->block[v->left_blk_idx][2]);
324 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
325 v->block[v->left_blk_idx][3]);
329 /** Do motion compensation over 1 macroblock
330 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
332 static void vc1_mc_1mv(VC1Context *v, int dir)
334 MpegEncContext *s = &v->s;
335 DSPContext *dsp = &v->s.dsp;
336 uint8_t *srcY, *srcU, *srcV;
337 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
339 int v_edge_pos = s->v_edge_pos >> v->field_mode;
341 if ((!v->field_mode ||
342 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
343 !v->s.last_picture.f.data[0])
346 mx = s->mv[dir][0][0];
347 my = s->mv[dir][0][1];
349 // store motion vectors for further use in B frames
350 if (s->pict_type == AV_PICTURE_TYPE_P) {
351 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
352 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
355 uvmx = (mx + ((mx & 3) == 3)) >> 1;
356 uvmy = (my + ((my & 3) == 3)) >> 1;
357 v->luma_mv[s->mb_x][0] = uvmx;
358 v->luma_mv[s->mb_x][1] = uvmy;
361 v->cur_field_type != v->ref_field_type[dir]) {
362 my = my - 2 + 4 * v->cur_field_type;
363 uvmy = uvmy - 2 + 4 * v->cur_field_type;
366 // fastuvmc shall be ignored for interlaced frame picture
367 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
368 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
369 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
371 if (v->field_mode) { // interlaced field picture
373 if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
374 srcY = s->current_picture.f.data[0];
375 srcU = s->current_picture.f.data[1];
376 srcV = s->current_picture.f.data[2];
378 srcY = s->last_picture.f.data[0];
379 srcU = s->last_picture.f.data[1];
380 srcV = s->last_picture.f.data[2];
383 srcY = s->next_picture.f.data[0];
384 srcU = s->next_picture.f.data[1];
385 srcV = s->next_picture.f.data[2];
389 srcY = s->last_picture.f.data[0];
390 srcU = s->last_picture.f.data[1];
391 srcV = s->last_picture.f.data[2];
393 srcY = s->next_picture.f.data[0];
394 srcU = s->next_picture.f.data[1];
395 srcV = s->next_picture.f.data[2];
399 src_x = s->mb_x * 16 + (mx >> 2);
400 src_y = s->mb_y * 16 + (my >> 2);
401 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
402 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
404 if (v->profile != PROFILE_ADVANCED) {
405 src_x = av_clip( src_x, -16, s->mb_width * 16);
406 src_y = av_clip( src_y, -16, s->mb_height * 16);
407 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
408 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
410 src_x = av_clip( src_x, -17, s->avctx->coded_width);
411 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
412 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
413 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
416 srcY += src_y * s->linesize + src_x;
417 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
418 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
420 if (v->field_mode && v->ref_field_type[dir]) {
421 srcY += s->current_picture_ptr->f.linesize[0];
422 srcU += s->current_picture_ptr->f.linesize[1];
423 srcV += s->current_picture_ptr->f.linesize[2];
426 /* for grayscale we should not try to read from unknown area */
427 if (s->flags & CODEC_FLAG_GRAY) {
428 srcU = s->edge_emu_buffer + 18 * s->linesize;
429 srcV = s->edge_emu_buffer + 18 * s->linesize;
432 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
433 || s->h_edge_pos < 22 || v_edge_pos < 22
434 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
435 || (unsigned)(src_y - s->mspel) > v_edge_pos - (my&3) - 16 - s->mspel * 3) {
436 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
438 srcY -= s->mspel * (1 + s->linesize);
439 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
440 17 + s->mspel * 2, 17 + s->mspel * 2,
441 src_x - s->mspel, src_y - s->mspel,
442 s->h_edge_pos, v_edge_pos);
443 srcY = s->edge_emu_buffer;
444 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
445 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
446 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
447 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
450 /* if we deal with range reduction we need to scale source blocks */
451 if (v->rangeredfrm) {
456 for (j = 0; j < 17 + s->mspel * 2; j++) {
457 for (i = 0; i < 17 + s->mspel * 2; i++)
458 src[i] = ((src[i] - 128) >> 1) + 128;
463 for (j = 0; j < 9; j++) {
464 for (i = 0; i < 9; i++) {
465 src[i] = ((src[i] - 128) >> 1) + 128;
466 src2[i] = ((src2[i] - 128) >> 1) + 128;
468 src += s->uvlinesize;
469 src2 += s->uvlinesize;
472 /* if we deal with intensity compensation we need to scale source blocks */
473 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
478 for (j = 0; j < 17 + s->mspel * 2; j++) {
479 for (i = 0; i < 17 + s->mspel * 2; i++)
480 src[i] = v->luty[src[i]];
485 for (j = 0; j < 9; j++) {
486 for (i = 0; i < 9; i++) {
487 src[i] = v->lutuv[src[i]];
488 src2[i] = v->lutuv[src2[i]];
490 src += s->uvlinesize;
491 src2 += s->uvlinesize;
494 srcY += s->mspel * (1 + s->linesize);
497 if (v->field_mode && v->second_field) {
498 off = s->current_picture_ptr->f.linesize[0];
499 off_uv = s->current_picture_ptr->f.linesize[1];
505 dxy = ((my & 3) << 2) | (mx & 3);
506 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
507 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
508 srcY += s->linesize * 8;
509 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
510 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
511 } else { // hpel mc - always used for luma
512 dxy = (my & 2) | ((mx & 2) >> 1);
514 dsp->put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
516 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
519 if (s->flags & CODEC_FLAG_GRAY) return;
520 /* Chroma MC always uses qpel bilinear */
521 uvmx = (uvmx & 3) << 1;
522 uvmy = (uvmy & 3) << 1;
524 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
525 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
527 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
528 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
532 static inline int median4(int a, int b, int c, int d)
535 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
536 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
538 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
539 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
543 /** Do motion compensation for 4-MV macroblock - luminance block
545 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
547 MpegEncContext *s = &v->s;
548 DSPContext *dsp = &v->s.dsp;
550 int dxy, mx, my, src_x, src_y;
552 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
553 int v_edge_pos = s->v_edge_pos >> v->field_mode;
555 if ((!v->field_mode ||
556 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
557 !v->s.last_picture.f.data[0])
560 mx = s->mv[dir][n][0];
561 my = s->mv[dir][n][1];
565 if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field)
566 srcY = s->current_picture.f.data[0];
568 srcY = s->last_picture.f.data[0];
570 srcY = s->last_picture.f.data[0];
572 srcY = s->next_picture.f.data[0];
575 if (v->cur_field_type != v->ref_field_type[dir])
576 my = my - 2 + 4 * v->cur_field_type;
579 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
580 int same_count = 0, opp_count = 0, k;
581 int chosen_mv[2][4][2], f;
583 for (k = 0; k < 4; k++) {
584 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
585 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
586 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
590 f = opp_count > same_count;
591 switch (f ? opp_count : same_count) {
593 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
594 chosen_mv[f][2][0], chosen_mv[f][3][0]);
595 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
596 chosen_mv[f][2][1], chosen_mv[f][3][1]);
599 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
600 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
603 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
604 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
607 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
608 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
609 for (k = 0; k < 4; k++)
610 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
613 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
615 int width = s->avctx->coded_width;
616 int height = s->avctx->coded_height >> 1;
617 qx = (s->mb_x * 16) + (mx >> 2);
618 qy = (s->mb_y * 8) + (my >> 3);
623 mx -= 4 * (qx - width);
626 else if (qy > height + 1)
627 my -= 8 * (qy - height - 1);
630 if ((v->fcm == ILACE_FRAME) && fieldmv)
631 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
633 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
634 if (v->field_mode && v->second_field)
635 off += s->current_picture_ptr->f.linesize[0];
637 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
639 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
641 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
643 if (v->profile != PROFILE_ADVANCED) {
644 src_x = av_clip(src_x, -16, s->mb_width * 16);
645 src_y = av_clip(src_y, -16, s->mb_height * 16);
647 src_x = av_clip(src_x, -17, s->avctx->coded_width);
648 if (v->fcm == ILACE_FRAME) {
650 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
652 src_y = av_clip(src_y, -18, s->avctx->coded_height);
654 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
658 srcY += src_y * s->linesize + src_x;
659 if (v->field_mode && v->ref_field_type[dir])
660 srcY += s->current_picture_ptr->f.linesize[0];
662 if (fieldmv && !(src_y & 1))
664 if (fieldmv && (src_y & 1) && src_y < 4)
666 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
667 || s->h_edge_pos < 13 || v_edge_pos < 23
668 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
669 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
670 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
671 /* check emulate edge stride and offset */
672 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
673 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
674 src_x - s->mspel, src_y - (s->mspel << fieldmv),
675 s->h_edge_pos, v_edge_pos);
676 srcY = s->edge_emu_buffer;
677 /* if we deal with range reduction we need to scale source blocks */
678 if (v->rangeredfrm) {
683 for (j = 0; j < 9 + s->mspel * 2; j++) {
684 for (i = 0; i < 9 + s->mspel * 2; i++)
685 src[i] = ((src[i] - 128) >> 1) + 128;
686 src += s->linesize << fieldmv;
689 /* if we deal with intensity compensation we need to scale source blocks */
690 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
695 for (j = 0; j < 9 + s->mspel * 2; j++) {
696 for (i = 0; i < 9 + s->mspel * 2; i++)
697 src[i] = v->luty[src[i]];
698 src += s->linesize << fieldmv;
701 srcY += s->mspel * (1 + (s->linesize << fieldmv));
705 dxy = ((my & 3) << 2) | (mx & 3);
706 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
707 } else { // hpel mc - always used for luma
708 dxy = (my & 2) | ((mx & 2) >> 1);
710 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
712 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
716 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
719 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
721 idx = ((a[3] != flag) << 3)
722 | ((a[2] != flag) << 2)
723 | ((a[1] != flag) << 1)
726 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
727 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
729 } else if (count[idx] == 1) {
732 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
733 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
736 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
737 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
740 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
741 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
744 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
745 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
748 } else if (count[idx] == 2) {
750 for (i = 0; i < 3; i++)
755 for (i = t1 + 1; i < 4; i++)
760 *tx = (mvx[t1] + mvx[t2]) / 2;
761 *ty = (mvy[t1] + mvy[t2]) / 2;
769 /** Do motion compensation for 4-MV macroblock - both chroma blocks
771 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
773 MpegEncContext *s = &v->s;
774 DSPContext *dsp = &v->s.dsp;
775 uint8_t *srcU, *srcV;
776 int uvmx, uvmy, uvsrc_x, uvsrc_y;
777 int k, tx = 0, ty = 0;
778 int mvx[4], mvy[4], intra[4], mv_f[4];
780 int chroma_ref_type = v->cur_field_type, off = 0;
781 int v_edge_pos = s->v_edge_pos >> v->field_mode;
783 if (!v->field_mode && !v->s.last_picture.f.data[0])
785 if (s->flags & CODEC_FLAG_GRAY)
788 for (k = 0; k < 4; k++) {
789 mvx[k] = s->mv[dir][k][0];
790 mvy[k] = s->mv[dir][k][1];
791 intra[k] = v->mb_type[0][s->block_index[k]];
793 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
796 /* calculate chroma MV vector from four luma MVs */
797 if (!v->field_mode || (v->field_mode && !v->numref)) {
798 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
800 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
801 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
802 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
803 return; //no need to do MC for intra blocks
807 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
809 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
811 chroma_ref_type = !v->cur_field_type;
813 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
815 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
816 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
817 uvmx = (tx + ((tx & 3) == 3)) >> 1;
818 uvmy = (ty + ((ty & 3) == 3)) >> 1;
820 v->luma_mv[s->mb_x][0] = uvmx;
821 v->luma_mv[s->mb_x][1] = uvmy;
824 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
825 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
827 // Field conversion bias
828 if (v->cur_field_type != chroma_ref_type)
829 uvmy += 2 - 4 * chroma_ref_type;
831 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
832 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
834 if (v->profile != PROFILE_ADVANCED) {
835 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
836 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
838 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
839 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
844 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
845 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
846 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
848 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
849 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
852 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
853 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
856 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
857 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
861 if (chroma_ref_type) {
862 srcU += s->current_picture_ptr->f.linesize[1];
863 srcV += s->current_picture_ptr->f.linesize[2];
865 off = v->second_field ? s->current_picture_ptr->f.linesize[1] : 0;
868 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
869 || s->h_edge_pos < 18 || v_edge_pos < 18
870 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
871 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
872 s->dsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
873 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
874 s->h_edge_pos >> 1, v_edge_pos >> 1);
875 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
876 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
877 s->h_edge_pos >> 1, v_edge_pos >> 1);
878 srcU = s->edge_emu_buffer;
879 srcV = s->edge_emu_buffer + 16;
881 /* if we deal with range reduction we need to scale source blocks */
882 if (v->rangeredfrm) {
888 for (j = 0; j < 9; j++) {
889 for (i = 0; i < 9; i++) {
890 src[i] = ((src[i] - 128) >> 1) + 128;
891 src2[i] = ((src2[i] - 128) >> 1) + 128;
893 src += s->uvlinesize;
894 src2 += s->uvlinesize;
897 /* if we deal with intensity compensation we need to scale source blocks */
898 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
904 for (j = 0; j < 9; j++) {
905 for (i = 0; i < 9; i++) {
906 src[i] = v->lutuv[src[i]];
907 src2[i] = v->lutuv[src2[i]];
909 src += s->uvlinesize;
910 src2 += s->uvlinesize;
915 /* Chroma MC always uses qpel bilinear */
916 uvmx = (uvmx & 3) << 1;
917 uvmy = (uvmy & 3) << 1;
919 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
920 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
922 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
923 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
927 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
929 static void vc1_mc_4mv_chroma4(VC1Context *v)
931 MpegEncContext *s = &v->s;
932 DSPContext *dsp = &v->s.dsp;
933 uint8_t *srcU, *srcV;
934 int uvsrc_x, uvsrc_y;
935 int uvmx_field[4], uvmy_field[4];
937 int fieldmv = v->blk_mv_type[s->block_index[0]];
938 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
939 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
940 int v_edge_pos = s->v_edge_pos >> 1;
942 if (!v->s.last_picture.f.data[0])
944 if (s->flags & CODEC_FLAG_GRAY)
947 for (i = 0; i < 4; i++) {
949 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
952 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
954 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
957 for (i = 0; i < 4; i++) {
958 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
959 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
960 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
961 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
962 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
963 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
964 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
965 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
966 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
967 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
969 if (fieldmv && !(uvsrc_y & 1))
971 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
973 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
974 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
975 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
976 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
977 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
978 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
979 s->h_edge_pos >> 1, v_edge_pos);
980 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
981 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
982 s->h_edge_pos >> 1, v_edge_pos);
983 srcU = s->edge_emu_buffer;
984 srcV = s->edge_emu_buffer + 16;
986 /* if we deal with intensity compensation we need to scale source blocks */
987 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
993 for (j = 0; j < 5; j++) {
994 for (i = 0; i < 5; i++) {
995 src[i] = v->lutuv[src[i]];
996 src2[i] = v->lutuv[src2[i]];
998 src += s->uvlinesize << 1;
999 src2 += s->uvlinesize << 1;
1004 dsp->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1005 dsp->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1007 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]);
1008 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]);
1013 /***********************************************************************/
1015 * @name VC-1 Block-level functions
1016 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1022 * @brief Get macroblock-level quantizer scale
1024 #define GET_MQUANT() \
1025 if (v->dquantfrm) { \
1027 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1028 if (v->dqbilevel) { \
1029 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1031 mqdiff = get_bits(gb, 3); \
1033 mquant = v->pq + mqdiff; \
1035 mquant = get_bits(gb, 5); \
1038 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1039 edges = 1 << v->dqsbedge; \
1040 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1041 edges = (3 << v->dqsbedge) % 15; \
1042 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1044 if ((edges&1) && !s->mb_x) \
1045 mquant = v->altpq; \
1046 if ((edges&2) && s->first_slice_line) \
1047 mquant = v->altpq; \
1048 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1049 mquant = v->altpq; \
1050 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1051 mquant = v->altpq; \
1052 if (!mquant || mquant > 31) { \
1053 av_log(v->s.avctx, AV_LOG_ERROR, "invalid mquant %d\n", mquant); \
1059 * @def GET_MVDATA(_dmv_x, _dmv_y)
1060 * @brief Get MV differentials
1061 * @see MVDATA decoding from 8.3.5.2, p(1)20
1062 * @param _dmv_x Horizontal differential for decoded MV
1063 * @param _dmv_y Vertical differential for decoded MV
1065 #define GET_MVDATA(_dmv_x, _dmv_y) \
1066 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1067 VC1_MV_DIFF_VLC_BITS, 2); \
1069 mb_has_coeffs = 1; \
1072 mb_has_coeffs = 0; \
1075 _dmv_x = _dmv_y = 0; \
1076 } else if (index == 35) { \
1077 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1078 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1079 } else if (index == 36) { \
1084 index1 = index % 6; \
1085 if (!s->quarter_sample && index1 == 5) val = 1; \
1087 if (size_table[index1] - val > 0) \
1088 val = get_bits(gb, size_table[index1] - val); \
1090 sign = 0 - (val&1); \
1091 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1093 index1 = index / 6; \
1094 if (!s->quarter_sample && index1 == 5) val = 1; \
1096 if (size_table[index1] - val > 0) \
1097 val = get_bits(gb, size_table[index1] - val); \
1099 sign = 0 - (val & 1); \
1100 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1103 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1104 int *dmv_y, int *pred_flag)
1107 int extend_x = 0, extend_y = 0;
1108 GetBitContext *gb = &v->s.gb;
1111 const int* offs_tab;
1114 bits = VC1_2REF_MVDATA_VLC_BITS;
1117 bits = VC1_1REF_MVDATA_VLC_BITS;
1120 switch (v->dmvrange) {
1128 extend_x = extend_y = 1;
1131 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1133 *dmv_x = get_bits(gb, v->k_x);
1134 *dmv_y = get_bits(gb, v->k_y);
1136 *pred_flag = *dmv_y & 1;
1137 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1141 av_assert0(index < esc);
1143 offs_tab = offset_table2;
1145 offs_tab = offset_table1;
1146 index1 = (index + 1) % 9;
1148 val = get_bits(gb, index1 + extend_x);
1149 sign = 0 -(val & 1);
1150 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1154 offs_tab = offset_table2;
1156 offs_tab = offset_table1;
1157 index1 = (index + 1) / 9;
1158 if (index1 > v->numref) {
1159 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1160 sign = 0 - (val & 1);
1161 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1165 *pred_flag = index1 & 1;
1169 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1171 int scaledvalue, refdist;
1172 int scalesame1, scalesame2;
1173 int scalezone1_x, zone1offset_x;
1174 int table_index = dir ^ v->second_field;
1176 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1177 refdist = v->refdist;
1179 refdist = dir ? v->brfd : v->frfd;
1182 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1183 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1184 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1185 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1190 if (FFABS(n) < scalezone1_x)
1191 scaledvalue = (n * scalesame1) >> 8;
1194 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1196 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1199 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1202 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1204 int scaledvalue, refdist;
1205 int scalesame1, scalesame2;
1206 int scalezone1_y, zone1offset_y;
1207 int table_index = dir ^ v->second_field;
1209 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1210 refdist = v->refdist;
1212 refdist = dir ? v->brfd : v->frfd;
1215 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1216 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1217 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1218 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1223 if (FFABS(n) < scalezone1_y)
1224 scaledvalue = (n * scalesame1) >> 8;
1227 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1229 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1233 if (v->cur_field_type && !v->ref_field_type[dir])
1234 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1236 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1239 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1241 int scalezone1_x, zone1offset_x;
1242 int scaleopp1, scaleopp2, brfd;
1245 brfd = FFMIN(v->brfd, 3);
1246 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1247 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1248 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1249 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1254 if (FFABS(n) < scalezone1_x)
1255 scaledvalue = (n * scaleopp1) >> 8;
1258 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1260 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1263 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1266 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1268 int scalezone1_y, zone1offset_y;
1269 int scaleopp1, scaleopp2, brfd;
1272 brfd = FFMIN(v->brfd, 3);
1273 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1274 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1275 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1276 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1281 if (FFABS(n) < scalezone1_y)
1282 scaledvalue = (n * scaleopp1) >> 8;
1285 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1287 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1290 if (v->cur_field_type && !v->ref_field_type[dir]) {
1291 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1293 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1297 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1300 int brfd, scalesame;
1301 int hpel = 1 - v->s.quarter_sample;
1304 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1306 n = scaleforsame_y(v, i, n, dir) << hpel;
1308 n = scaleforsame_x(v, n, dir) << hpel;
1311 brfd = FFMIN(v->brfd, 3);
1312 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1314 n = (n * scalesame >> 8) << hpel;
1318 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1321 int refdist, scaleopp;
1322 int hpel = 1 - v->s.quarter_sample;
1325 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1327 n = scaleforopp_y(v, n, dir) << hpel;
1329 n = scaleforopp_x(v, n) << hpel;
1332 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1333 refdist = FFMIN(v->refdist, 3);
1335 refdist = dir ? v->brfd : v->frfd;
1336 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1338 n = (n * scaleopp >> 8) << hpel;
1342 /** Predict and set motion vector
1344 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1345 int mv1, int r_x, int r_y, uint8_t* is_intra,
1346 int pred_flag, int dir)
1348 MpegEncContext *s = &v->s;
1349 int xy, wrap, off = 0;
1353 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1354 int opposit, a_f, b_f, c_f;
1355 int16_t field_predA[2];
1356 int16_t field_predB[2];
1357 int16_t field_predC[2];
1358 int a_valid, b_valid, c_valid;
1359 int hybridmv_thresh, y_bias = 0;
1361 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1362 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1366 /* scale MV difference to be quad-pel */
1367 dmv_x <<= 1 - s->quarter_sample;
1368 dmv_y <<= 1 - s->quarter_sample;
1370 wrap = s->b8_stride;
1371 xy = s->block_index[n];
1374 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
1375 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
1376 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
1377 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
1378 if (mv1) { /* duplicate motion data for 1-MV block */
1379 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1380 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1381 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1382 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1383 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1384 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1385 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1386 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1387 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1388 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1389 s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1390 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1391 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1396 C = s->current_picture.f.motion_val[dir][xy - 1 + v->blocks_off];
1397 A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
1399 if (v->field_mode && mixedmv_pic)
1400 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1402 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1404 //in 4-MV mode different blocks have different B predictor position
1407 off = (s->mb_x > 0) ? -1 : 1;
1410 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1419 B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
1421 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1422 b_valid = a_valid && (s->mb_width > 1);
1423 c_valid = s->mb_x || (n == 1 || n == 3);
1424 if (v->field_mode) {
1425 a_valid = a_valid && !is_intra[xy - wrap];
1426 b_valid = b_valid && !is_intra[xy - wrap + off];
1427 c_valid = c_valid && !is_intra[xy - 1];
1431 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1432 num_oppfield += a_f;
1433 num_samefield += 1 - a_f;
1434 field_predA[0] = A[0];
1435 field_predA[1] = A[1];
1437 field_predA[0] = field_predA[1] = 0;
1441 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1442 num_oppfield += b_f;
1443 num_samefield += 1 - b_f;
1444 field_predB[0] = B[0];
1445 field_predB[1] = B[1];
1447 field_predB[0] = field_predB[1] = 0;
1451 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1452 num_oppfield += c_f;
1453 num_samefield += 1 - c_f;
1454 field_predC[0] = C[0];
1455 field_predC[1] = C[1];
1457 field_predC[0] = field_predC[1] = 0;
1461 if (v->field_mode) {
1462 if (num_samefield <= num_oppfield)
1463 opposit = 1 - pred_flag;
1465 opposit = pred_flag;
1469 if (a_valid && !a_f) {
1470 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1471 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1473 if (b_valid && !b_f) {
1474 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1475 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1477 if (c_valid && !c_f) {
1478 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1479 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1481 v->mv_f[dir][xy + v->blocks_off] = 1;
1482 v->ref_field_type[dir] = !v->cur_field_type;
1484 if (a_valid && a_f) {
1485 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1486 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1488 if (b_valid && b_f) {
1489 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1490 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1492 if (c_valid && c_f) {
1493 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1494 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1496 v->mv_f[dir][xy + v->blocks_off] = 0;
1497 v->ref_field_type[dir] = v->cur_field_type;
1501 px = field_predA[0];
1502 py = field_predA[1];
1503 } else if (c_valid) {
1504 px = field_predC[0];
1505 py = field_predC[1];
1506 } else if (b_valid) {
1507 px = field_predB[0];
1508 py = field_predB[1];
1514 if (num_samefield + num_oppfield > 1) {
1515 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1516 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1519 /* Pullback MV as specified in 8.3.5.3.4 */
1520 if (!v->field_mode) {
1522 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1523 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1524 X = (s->mb_width << 6) - 4;
1525 Y = (s->mb_height << 6) - 4;
1527 if (qx + px < -60) px = -60 - qx;
1528 if (qy + py < -60) py = -60 - qy;
1530 if (qx + px < -28) px = -28 - qx;
1531 if (qy + py < -28) py = -28 - qy;
1533 if (qx + px > X) px = X - qx;
1534 if (qy + py > Y) py = Y - qy;
1537 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1538 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1539 hybridmv_thresh = 32;
1540 if (a_valid && c_valid) {
1541 if (is_intra[xy - wrap])
1542 sum = FFABS(px) + FFABS(py);
1544 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1545 if (sum > hybridmv_thresh) {
1546 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1547 px = field_predA[0];
1548 py = field_predA[1];
1550 px = field_predC[0];
1551 py = field_predC[1];
1554 if (is_intra[xy - 1])
1555 sum = FFABS(px) + FFABS(py);
1557 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1558 if (sum > hybridmv_thresh) {
1559 if (get_bits1(&s->gb)) {
1560 px = field_predA[0];
1561 py = field_predA[1];
1563 px = field_predC[0];
1564 py = field_predC[1];
1571 if (v->field_mode && !s->quarter_sample) {
1575 if (v->field_mode && v->numref)
1577 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1579 /* store MV using signed modulus of MV range defined in 4.11 */
1580 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;
1581 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;
1582 if (mv1) { /* duplicate motion data for 1-MV block */
1583 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];
1584 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];
1585 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];
1586 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];
1587 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];
1588 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];
1589 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1590 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];
1594 /** Predict and set motion vector for interlaced frame picture MBs
1596 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1597 int mvn, int r_x, int r_y, uint8_t* is_intra)
1599 MpegEncContext *s = &v->s;
1600 int xy, wrap, off = 0;
1601 int A[2], B[2], C[2];
1603 int a_valid = 0, b_valid = 0, c_valid = 0;
1604 int field_a, field_b, field_c; // 0: same, 1: opposit
1605 int total_valid, num_samefield, num_oppfield;
1606 int pos_c, pos_b, n_adj;
1608 wrap = s->b8_stride;
1609 xy = s->block_index[n];
1612 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
1613 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
1614 s->current_picture.f.motion_val[1][xy][0] = 0;
1615 s->current_picture.f.motion_val[1][xy][1] = 0;
1616 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1617 s->current_picture.f.motion_val[0][xy + 1][0] = 0;
1618 s->current_picture.f.motion_val[0][xy + 1][1] = 0;
1619 s->current_picture.f.motion_val[0][xy + wrap][0] = 0;
1620 s->current_picture.f.motion_val[0][xy + wrap][1] = 0;
1621 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
1622 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
1623 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1624 s->current_picture.f.motion_val[1][xy + 1][0] = 0;
1625 s->current_picture.f.motion_val[1][xy + 1][1] = 0;
1626 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1627 s->current_picture.f.motion_val[1][xy + wrap][1] = 0;
1628 s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
1629 s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
1634 off = ((n == 0) || (n == 1)) ? 1 : -1;
1636 if (s->mb_x || (n == 1) || (n == 3)) {
1637 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1638 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1639 A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
1640 A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
1642 } else { // current block has frame mv and cand. has field MV (so average)
1643 A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
1644 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1645 A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
1646 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1649 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1655 /* Predict B and C */
1656 B[0] = B[1] = C[0] = C[1] = 0;
1657 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1658 if (!s->first_slice_line) {
1659 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1662 pos_b = s->block_index[n_adj] - 2 * wrap;
1663 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1664 n_adj = (n & 2) | (n & 1);
1666 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1667 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1668 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1669 B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1670 B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1673 if (s->mb_width > 1) {
1674 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1677 pos_c = s->block_index[2] - 2 * wrap + 2;
1678 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1681 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1682 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1683 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1684 C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1685 C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1687 if (s->mb_x == s->mb_width - 1) {
1688 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1691 pos_c = s->block_index[3] - 2 * wrap - 2;
1692 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1695 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1696 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1697 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1698 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1699 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1708 pos_b = s->block_index[1];
1710 B[0] = s->current_picture.f.motion_val[0][pos_b][0];
1711 B[1] = s->current_picture.f.motion_val[0][pos_b][1];
1712 pos_c = s->block_index[0];
1714 C[0] = s->current_picture.f.motion_val[0][pos_c][0];
1715 C[1] = s->current_picture.f.motion_val[0][pos_c][1];
1718 total_valid = a_valid + b_valid + c_valid;
1719 // check if predictor A is out of bounds
1720 if (!s->mb_x && !(n == 1 || n == 3)) {
1723 // check if predictor B is out of bounds
1724 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1725 B[0] = B[1] = C[0] = C[1] = 0;
1727 if (!v->blk_mv_type[xy]) {
1728 if (s->mb_width == 1) {
1732 if (total_valid >= 2) {
1733 px = mid_pred(A[0], B[0], C[0]);
1734 py = mid_pred(A[1], B[1], C[1]);
1735 } else if (total_valid) {
1736 if (a_valid) { px = A[0]; py = A[1]; }
1737 if (b_valid) { px = B[0]; py = B[1]; }
1738 if (c_valid) { px = C[0]; py = C[1]; }
1744 field_a = (A[1] & 4) ? 1 : 0;
1748 field_b = (B[1] & 4) ? 1 : 0;
1752 field_c = (C[1] & 4) ? 1 : 0;
1756 num_oppfield = field_a + field_b + field_c;
1757 num_samefield = total_valid - num_oppfield;
1758 if (total_valid == 3) {
1759 if ((num_samefield == 3) || (num_oppfield == 3)) {
1760 px = mid_pred(A[0], B[0], C[0]);
1761 py = mid_pred(A[1], B[1], C[1]);
1762 } else if (num_samefield >= num_oppfield) {
1763 /* take one MV from same field set depending on priority
1764 the check for B may not be necessary */
1765 px = !field_a ? A[0] : B[0];
1766 py = !field_a ? A[1] : B[1];
1768 px = field_a ? A[0] : B[0];
1769 py = field_a ? A[1] : B[1];
1771 } else if (total_valid == 2) {
1772 if (num_samefield >= num_oppfield) {
1773 if (!field_a && a_valid) {
1776 } else if (!field_b && b_valid) {
1779 } else if (c_valid) {
1784 if (field_a && a_valid) {
1787 } else if (field_b && b_valid) {
1790 } else if (c_valid) {
1795 } else if (total_valid == 1) {
1796 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1797 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1802 /* store MV using signed modulus of MV range defined in 4.11 */
1803 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;
1804 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;
1805 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1806 s->current_picture.f.motion_val[0][xy + 1 ][0] = s->current_picture.f.motion_val[0][xy][0];
1807 s->current_picture.f.motion_val[0][xy + 1 ][1] = s->current_picture.f.motion_val[0][xy][1];
1808 s->current_picture.f.motion_val[0][xy + wrap ][0] = s->current_picture.f.motion_val[0][xy][0];
1809 s->current_picture.f.motion_val[0][xy + wrap ][1] = s->current_picture.f.motion_val[0][xy][1];
1810 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1811 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1812 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1813 s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1814 s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1815 s->mv[0][n + 1][0] = s->mv[0][n][0];
1816 s->mv[0][n + 1][1] = s->mv[0][n][1];
1820 /** Motion compensation for direct or interpolated blocks in B-frames
1822 static void vc1_interp_mc(VC1Context *v)
1824 MpegEncContext *s = &v->s;
1825 DSPContext *dsp = &v->s.dsp;
1826 uint8_t *srcY, *srcU, *srcV;
1827 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1829 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1831 if (!v->field_mode && !v->s.next_picture.f.data[0])
1834 mx = s->mv[1][0][0];
1835 my = s->mv[1][0][1];
1836 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1837 uvmy = (my + ((my & 3) == 3)) >> 1;
1838 if (v->field_mode) {
1839 if (v->cur_field_type != v->ref_field_type[1])
1840 my = my - 2 + 4 * v->cur_field_type;
1841 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1844 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1845 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1847 srcY = s->next_picture.f.data[0];
1848 srcU = s->next_picture.f.data[1];
1849 srcV = s->next_picture.f.data[2];
1851 src_x = s->mb_x * 16 + (mx >> 2);
1852 src_y = s->mb_y * 16 + (my >> 2);
1853 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1854 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1856 if (v->profile != PROFILE_ADVANCED) {
1857 src_x = av_clip( src_x, -16, s->mb_width * 16);
1858 src_y = av_clip( src_y, -16, s->mb_height * 16);
1859 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1860 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1862 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1863 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1864 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1865 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1868 srcY += src_y * s->linesize + src_x;
1869 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1870 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1872 if (v->field_mode && v->ref_field_type[1]) {
1873 srcY += s->current_picture_ptr->f.linesize[0];
1874 srcU += s->current_picture_ptr->f.linesize[1];
1875 srcV += s->current_picture_ptr->f.linesize[2];
1878 /* for grayscale we should not try to read from unknown area */
1879 if (s->flags & CODEC_FLAG_GRAY) {
1880 srcU = s->edge_emu_buffer + 18 * s->linesize;
1881 srcV = s->edge_emu_buffer + 18 * s->linesize;
1884 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1885 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 16 - s->mspel * 3
1886 || (unsigned)(src_y - s->mspel) > v_edge_pos - (my & 3) - 16 - s->mspel * 3) {
1887 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1889 srcY -= s->mspel * (1 + s->linesize);
1890 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1891 17 + s->mspel * 2, 17 + s->mspel * 2,
1892 src_x - s->mspel, src_y - s->mspel,
1893 s->h_edge_pos, v_edge_pos);
1894 srcY = s->edge_emu_buffer;
1895 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1896 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1897 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1898 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1901 /* if we deal with range reduction we need to scale source blocks */
1902 if (v->rangeredfrm) {
1904 uint8_t *src, *src2;
1907 for (j = 0; j < 17 + s->mspel * 2; j++) {
1908 for (i = 0; i < 17 + s->mspel * 2; i++)
1909 src[i] = ((src[i] - 128) >> 1) + 128;
1914 for (j = 0; j < 9; j++) {
1915 for (i = 0; i < 9; i++) {
1916 src[i] = ((src[i] - 128) >> 1) + 128;
1917 src2[i] = ((src2[i] - 128) >> 1) + 128;
1919 src += s->uvlinesize;
1920 src2 += s->uvlinesize;
1923 srcY += s->mspel * (1 + s->linesize);
1926 if (v->field_mode && v->second_field) {
1927 off = s->current_picture_ptr->f.linesize[0];
1928 off_uv = s->current_picture_ptr->f.linesize[1];
1935 dxy = ((my & 3) << 2) | (mx & 3);
1936 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
1937 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1938 srcY += s->linesize * 8;
1939 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
1940 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1942 dxy = (my & 2) | ((mx & 2) >> 1);
1945 dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1947 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1950 if (s->flags & CODEC_FLAG_GRAY) return;
1951 /* Chroma MC always uses qpel blilinear */
1952 uvmx = (uvmx & 3) << 1;
1953 uvmy = (uvmy & 3) << 1;
1955 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1956 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1958 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1959 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1963 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1967 #if B_FRACTION_DEN==256
1971 return 2 * ((value * n + 255) >> 9);
1972 return (value * n + 128) >> 8;
1975 n -= B_FRACTION_DEN;
1977 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1978 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1982 static av_always_inline int scale_mv_intfi(int value, int bfrac, int inv,
1983 int qs, int qs_last)
1991 return (value * n + 255) >> 9;
1993 return (value * n + 128) >> 8;
1996 /** Reconstruct motion vector for B-frame and do motion compensation
1998 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
1999 int direct, int mode)
2002 v->mv_mode2 = v->mv_mode;
2003 v->mv_mode = MV_PMODE_INTENSITY_COMP;
2009 v->mv_mode = v->mv_mode2;
2012 if (mode == BMV_TYPE_INTERPOLATED) {
2016 v->mv_mode = v->mv_mode2;
2020 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2021 v->mv_mode = v->mv_mode2;
2022 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2024 v->mv_mode = v->mv_mode2;
2027 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2028 int direct, int mvtype)
2030 MpegEncContext *s = &v->s;
2031 int xy, wrap, off = 0;
2036 const uint8_t *is_intra = v->mb_type[0];
2040 /* scale MV difference to be quad-pel */
2041 dmv_x[0] <<= 1 - s->quarter_sample;
2042 dmv_y[0] <<= 1 - s->quarter_sample;
2043 dmv_x[1] <<= 1 - s->quarter_sample;
2044 dmv_y[1] <<= 1 - s->quarter_sample;
2046 wrap = s->b8_stride;
2047 xy = s->block_index[0];
2050 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
2051 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
2052 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
2053 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
2056 if (!v->field_mode) {
2057 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2058 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2059 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2060 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2062 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2063 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));
2064 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));
2065 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));
2066 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));
2069 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2070 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2071 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2072 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2076 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2077 C = s->current_picture.f.motion_val[0][xy - 2];
2078 A = s->current_picture.f.motion_val[0][xy - wrap * 2];
2079 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2080 B = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
2082 if (!s->mb_x) C[0] = C[1] = 0;
2083 if (!s->first_slice_line) { // predictor A is not out of bounds
2084 if (s->mb_width == 1) {
2088 px = mid_pred(A[0], B[0], C[0]);
2089 py = mid_pred(A[1], B[1], C[1]);
2091 } else if (s->mb_x) { // predictor C is not out of bounds
2097 /* Pullback MV as specified in 8.3.5.3.4 */
2100 if (v->profile < PROFILE_ADVANCED) {
2101 qx = (s->mb_x << 5);
2102 qy = (s->mb_y << 5);
2103 X = (s->mb_width << 5) - 4;
2104 Y = (s->mb_height << 5) - 4;
2105 if (qx + px < -28) px = -28 - qx;
2106 if (qy + py < -28) py = -28 - qy;
2107 if (qx + px > X) px = X - qx;
2108 if (qy + py > Y) py = Y - qy;
2110 qx = (s->mb_x << 6);
2111 qy = (s->mb_y << 6);
2112 X = (s->mb_width << 6) - 4;
2113 Y = (s->mb_height << 6) - 4;
2114 if (qx + px < -60) px = -60 - qx;
2115 if (qy + py < -60) py = -60 - qy;
2116 if (qx + px > X) px = X - qx;
2117 if (qy + py > Y) py = Y - qy;
2120 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2121 if (0 && !s->first_slice_line && s->mb_x) {
2122 if (is_intra[xy - wrap])
2123 sum = FFABS(px) + FFABS(py);
2125 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2127 if (get_bits1(&s->gb)) {
2135 if (is_intra[xy - 2])
2136 sum = FFABS(px) + FFABS(py);
2138 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2140 if (get_bits1(&s->gb)) {
2150 /* store MV using signed modulus of MV range defined in 4.11 */
2151 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2152 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2154 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2155 C = s->current_picture.f.motion_val[1][xy - 2];
2156 A = s->current_picture.f.motion_val[1][xy - wrap * 2];
2157 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2158 B = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
2162 if (!s->first_slice_line) { // predictor A is not out of bounds
2163 if (s->mb_width == 1) {
2167 px = mid_pred(A[0], B[0], C[0]);
2168 py = mid_pred(A[1], B[1], C[1]);
2170 } else if (s->mb_x) { // predictor C is not out of bounds
2176 /* Pullback MV as specified in 8.3.5.3.4 */
2179 if (v->profile < PROFILE_ADVANCED) {
2180 qx = (s->mb_x << 5);
2181 qy = (s->mb_y << 5);
2182 X = (s->mb_width << 5) - 4;
2183 Y = (s->mb_height << 5) - 4;
2184 if (qx + px < -28) px = -28 - qx;
2185 if (qy + py < -28) py = -28 - qy;
2186 if (qx + px > X) px = X - qx;
2187 if (qy + py > Y) py = Y - qy;
2189 qx = (s->mb_x << 6);
2190 qy = (s->mb_y << 6);
2191 X = (s->mb_width << 6) - 4;
2192 Y = (s->mb_height << 6) - 4;
2193 if (qx + px < -60) px = -60 - qx;
2194 if (qy + py < -60) py = -60 - qy;
2195 if (qx + px > X) px = X - qx;
2196 if (qy + py > Y) py = Y - qy;
2199 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2200 if (0 && !s->first_slice_line && s->mb_x) {
2201 if (is_intra[xy - wrap])
2202 sum = FFABS(px) + FFABS(py);
2204 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2206 if (get_bits1(&s->gb)) {
2214 if (is_intra[xy - 2])
2215 sum = FFABS(px) + FFABS(py);
2217 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2219 if (get_bits1(&s->gb)) {
2229 /* store MV using signed modulus of MV range defined in 4.11 */
2231 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2232 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2234 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
2235 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
2236 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
2237 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
2240 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2242 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2243 MpegEncContext *s = &v->s;
2244 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2246 if (v->bmvtype == BMV_TYPE_DIRECT) {
2247 int total_opp, k, f;
2248 if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2249 s->mv[0][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2250 v->bfraction, 0, s->quarter_sample, v->qs_last);
2251 s->mv[0][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2252 v->bfraction, 0, s->quarter_sample, v->qs_last);
2253 s->mv[1][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2254 v->bfraction, 1, s->quarter_sample, v->qs_last);
2255 s->mv[1][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2256 v->bfraction, 1, s->quarter_sample, v->qs_last);
2258 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2259 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2260 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2261 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2262 f = (total_opp > 2) ? 1 : 0;
2264 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2265 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2268 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2269 for (k = 0; k < 4; k++) {
2270 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2271 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2272 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2273 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2274 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2275 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2279 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2280 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);
2281 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);
2284 if (dir) { // backward
2285 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);
2286 if (n == 3 || mv1) {
2287 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2290 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);
2291 if (n == 3 || mv1) {
2292 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2297 /** Get predicted DC value for I-frames only
2298 * prediction dir: left=0, top=1
2299 * @param s MpegEncContext
2300 * @param overlap flag indicating that overlap filtering is used
2301 * @param pq integer part of picture quantizer
2302 * @param[in] n block index in the current MB
2303 * @param dc_val_ptr Pointer to DC predictor
2304 * @param dir_ptr Prediction direction for use in AC prediction
2306 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2307 int16_t **dc_val_ptr, int *dir_ptr)
2309 int a, b, c, wrap, pred, scale;
2311 static const uint16_t dcpred[32] = {
2312 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2313 114, 102, 93, 85, 79, 73, 68, 64,
2314 60, 57, 54, 51, 49, 47, 45, 43,
2315 41, 39, 38, 37, 35, 34, 33
2318 /* find prediction - wmv3_dc_scale always used here in fact */
2319 if (n < 4) scale = s->y_dc_scale;
2320 else scale = s->c_dc_scale;
2322 wrap = s->block_wrap[n];
2323 dc_val = s->dc_val[0] + s->block_index[n];
2329 b = dc_val[ - 1 - wrap];
2330 a = dc_val[ - wrap];
2332 if (pq < 9 || !overlap) {
2333 /* Set outer values */
2334 if (s->first_slice_line && (n != 2 && n != 3))
2335 b = a = dcpred[scale];
2336 if (s->mb_x == 0 && (n != 1 && n != 3))
2337 b = c = dcpred[scale];
2339 /* Set outer values */
2340 if (s->first_slice_line && (n != 2 && n != 3))
2342 if (s->mb_x == 0 && (n != 1 && n != 3))
2346 if (abs(a - b) <= abs(b - c)) {
2348 *dir_ptr = 1; // left
2351 *dir_ptr = 0; // top
2354 /* update predictor */
2355 *dc_val_ptr = &dc_val[0];
2360 /** Get predicted DC value
2361 * prediction dir: left=0, top=1
2362 * @param s MpegEncContext
2363 * @param overlap flag indicating that overlap filtering is used
2364 * @param pq integer part of picture quantizer
2365 * @param[in] n block index in the current MB
2366 * @param a_avail flag indicating top block availability
2367 * @param c_avail flag indicating left block availability
2368 * @param dc_val_ptr Pointer to DC predictor
2369 * @param dir_ptr Prediction direction for use in AC prediction
2371 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2372 int a_avail, int c_avail,
2373 int16_t **dc_val_ptr, int *dir_ptr)
2375 int a, b, c, wrap, pred;
2377 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2381 wrap = s->block_wrap[n];
2382 dc_val = s->dc_val[0] + s->block_index[n];
2388 b = dc_val[ - 1 - wrap];
2389 a = dc_val[ - wrap];
2390 /* scale predictors if needed */
2391 q1 = s->current_picture.f.qscale_table[mb_pos];
2392 dqscale_index = s->y_dc_scale_table[q1] - 1;
2393 if (dqscale_index < 0)
2395 if (c_avail && (n != 1 && n != 3)) {
2396 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2398 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2400 if (a_avail && (n != 2 && n != 3)) {
2401 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2403 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2405 if (a_avail && c_avail && (n != 3)) {
2410 off -= s->mb_stride;
2411 q2 = s->current_picture.f.qscale_table[off];
2413 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2416 if (a_avail && c_avail) {
2417 if (abs(a - b) <= abs(b - c)) {
2419 *dir_ptr = 1; // left
2422 *dir_ptr = 0; // top
2424 } else if (a_avail) {
2426 *dir_ptr = 0; // top
2427 } else if (c_avail) {
2429 *dir_ptr = 1; // left
2432 *dir_ptr = 1; // left
2435 /* update predictor */
2436 *dc_val_ptr = &dc_val[0];
2440 /** @} */ // Block group
2443 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2444 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2448 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2449 uint8_t **coded_block_ptr)
2451 int xy, wrap, pred, a, b, c;
2453 xy = s->block_index[n];
2454 wrap = s->b8_stride;
2459 a = s->coded_block[xy - 1 ];
2460 b = s->coded_block[xy - 1 - wrap];
2461 c = s->coded_block[xy - wrap];
2470 *coded_block_ptr = &s->coded_block[xy];
2476 * Decode one AC coefficient
2477 * @param v The VC1 context
2478 * @param last Last coefficient
2479 * @param skip How much zero coefficients to skip
2480 * @param value Decoded AC coefficient value
2481 * @param codingset set of VLC to decode data
2484 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2485 int *value, int codingset)
2487 GetBitContext *gb = &v->s.gb;
2488 int index, escape, run = 0, level = 0, lst = 0;
2490 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2491 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2492 run = vc1_index_decode_table[codingset][index][0];
2493 level = vc1_index_decode_table[codingset][index][1];
2494 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2498 escape = decode210(gb);
2500 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2501 run = vc1_index_decode_table[codingset][index][0];
2502 level = vc1_index_decode_table[codingset][index][1];
2503 lst = index >= vc1_last_decode_table[codingset];
2506 level += vc1_last_delta_level_table[codingset][run];
2508 level += vc1_delta_level_table[codingset][run];
2511 run += vc1_last_delta_run_table[codingset][level] + 1;
2513 run += vc1_delta_run_table[codingset][level] + 1;
2519 lst = get_bits1(gb);
2520 if (v->s.esc3_level_length == 0) {
2521 if (v->pq < 8 || v->dquantfrm) { // table 59
2522 v->s.esc3_level_length = get_bits(gb, 3);
2523 if (!v->s.esc3_level_length)
2524 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2525 } else { // table 60
2526 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2528 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2530 run = get_bits(gb, v->s.esc3_run_length);
2531 sign = get_bits1(gb);
2532 level = get_bits(gb, v->s.esc3_level_length);
2543 /** Decode intra block in intra frames - should be faster than decode_intra_block
2544 * @param v VC1Context
2545 * @param block block to decode
2546 * @param[in] n subblock index
2547 * @param coded are AC coeffs present or not
2548 * @param codingset set of VLC to decode data
2550 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
2551 int coded, int codingset)
2553 GetBitContext *gb = &v->s.gb;
2554 MpegEncContext *s = &v->s;
2555 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2558 int16_t *ac_val, *ac_val2;
2561 /* Get DC differential */
2563 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2565 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2568 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2572 if (dcdiff == 119 /* ESC index value */) {
2573 /* TODO: Optimize */
2574 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2575 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2576 else dcdiff = get_bits(gb, 8);
2579 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2580 else if (v->pq == 2)
2581 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2588 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2591 /* Store the quantized DC coeff, used for prediction */
2593 block[0] = dcdiff * s->y_dc_scale;
2595 block[0] = dcdiff * s->c_dc_scale;
2606 int last = 0, skip, value;
2607 const uint8_t *zz_table;
2611 scale = v->pq * 2 + v->halfpq;
2615 zz_table = v->zz_8x8[2];
2617 zz_table = v->zz_8x8[3];
2619 zz_table = v->zz_8x8[1];
2621 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2623 if (dc_pred_dir) // left
2626 ac_val -= 16 * s->block_wrap[n];
2629 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2633 block[zz_table[i++]] = value;
2636 /* apply AC prediction if needed */
2638 if (dc_pred_dir) { // left
2639 for (k = 1; k < 8; k++)
2640 block[k << v->left_blk_sh] += ac_val[k];
2642 for (k = 1; k < 8; k++)
2643 block[k << v->top_blk_sh] += ac_val[k + 8];
2646 /* save AC coeffs for further prediction */
2647 for (k = 1; k < 8; k++) {
2648 ac_val2[k] = block[k << v->left_blk_sh];
2649 ac_val2[k + 8] = block[k << v->top_blk_sh];
2652 /* scale AC coeffs */
2653 for (k = 1; k < 64; k++)
2657 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2660 if (s->ac_pred) i = 63;
2666 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2670 scale = v->pq * 2 + v->halfpq;
2671 memset(ac_val2, 0, 16 * 2);
2672 if (dc_pred_dir) { // left
2675 memcpy(ac_val2, ac_val, 8 * 2);
2677 ac_val -= 16 * s->block_wrap[n];
2679 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2682 /* apply AC prediction if needed */
2684 if (dc_pred_dir) { //left
2685 for (k = 1; k < 8; k++) {
2686 block[k << v->left_blk_sh] = ac_val[k] * scale;
2687 if (!v->pquantizer && block[k << v->left_blk_sh])
2688 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2691 for (k = 1; k < 8; k++) {
2692 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2693 if (!v->pquantizer && block[k << v->top_blk_sh])
2694 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2700 s->block_last_index[n] = i;
2705 /** Decode intra block in intra frames - should be faster than decode_intra_block
2706 * @param v VC1Context
2707 * @param block block to decode
2708 * @param[in] n subblock number
2709 * @param coded are AC coeffs present or not
2710 * @param codingset set of VLC to decode data
2711 * @param mquant quantizer value for this macroblock
2713 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
2714 int coded, int codingset, int mquant)
2716 GetBitContext *gb = &v->s.gb;
2717 MpegEncContext *s = &v->s;
2718 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2721 int16_t *ac_val, *ac_val2;
2723 int a_avail = v->a_avail, c_avail = v->c_avail;
2724 int use_pred = s->ac_pred;
2727 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2729 /* Get DC differential */
2731 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2733 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2736 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2740 if (dcdiff == 119 /* ESC index value */) {
2741 /* TODO: Optimize */
2742 if (mquant == 1) dcdiff = get_bits(gb, 10);
2743 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2744 else dcdiff = get_bits(gb, 8);
2747 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2748 else if (mquant == 2)
2749 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2756 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2759 /* Store the quantized DC coeff, used for prediction */
2761 block[0] = dcdiff * s->y_dc_scale;
2763 block[0] = dcdiff * s->c_dc_scale;
2769 /* check if AC is needed at all */
2770 if (!a_avail && !c_avail)
2772 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2775 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2777 if (dc_pred_dir) // left
2780 ac_val -= 16 * s->block_wrap[n];
2782 q1 = s->current_picture.f.qscale_table[mb_pos];
2783 if ( dc_pred_dir && c_avail && mb_pos)
2784 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2785 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2786 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2787 if ( dc_pred_dir && n == 1)
2789 if (!dc_pred_dir && n == 2)
2795 int last = 0, skip, value;
2796 const uint8_t *zz_table;
2800 if (!use_pred && v->fcm == ILACE_FRAME) {
2801 zz_table = v->zzi_8x8;
2803 if (!dc_pred_dir) // top
2804 zz_table = v->zz_8x8[2];
2806 zz_table = v->zz_8x8[3];
2809 if (v->fcm != ILACE_FRAME)
2810 zz_table = v->zz_8x8[1];
2812 zz_table = v->zzi_8x8;
2816 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2820 block[zz_table[i++]] = value;
2823 /* apply AC prediction if needed */
2825 /* scale predictors if needed*/
2826 if (q2 && q1 != q2) {
2827 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2828 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2831 return AVERROR_INVALIDDATA;
2832 if (dc_pred_dir) { // left
2833 for (k = 1; k < 8; k++)
2834 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2836 for (k = 1; k < 8; k++)
2837 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2840 if (dc_pred_dir) { //left
2841 for (k = 1; k < 8; k++)
2842 block[k << v->left_blk_sh] += ac_val[k];
2844 for (k = 1; k < 8; k++)
2845 block[k << v->top_blk_sh] += ac_val[k + 8];
2849 /* save AC coeffs for further prediction */
2850 for (k = 1; k < 8; k++) {
2851 ac_val2[k ] = block[k << v->left_blk_sh];
2852 ac_val2[k + 8] = block[k << v->top_blk_sh];
2855 /* scale AC coeffs */
2856 for (k = 1; k < 64; k++)
2860 block[k] += (block[k] < 0) ? -mquant : mquant;
2863 if (use_pred) i = 63;
2864 } else { // no AC coeffs
2867 memset(ac_val2, 0, 16 * 2);
2868 if (dc_pred_dir) { // left
2870 memcpy(ac_val2, ac_val, 8 * 2);
2871 if (q2 && q1 != q2) {
2872 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2873 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2875 return AVERROR_INVALIDDATA;
2876 for (k = 1; k < 8; k++)
2877 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2882 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2883 if (q2 && q1 != q2) {
2884 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2885 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2887 return AVERROR_INVALIDDATA;
2888 for (k = 1; k < 8; k++)
2889 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2894 /* apply AC prediction if needed */
2896 if (dc_pred_dir) { // left
2897 for (k = 1; k < 8; k++) {
2898 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2899 if (!v->pquantizer && block[k << v->left_blk_sh])
2900 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2903 for (k = 1; k < 8; k++) {
2904 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2905 if (!v->pquantizer && block[k << v->top_blk_sh])
2906 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2912 s->block_last_index[n] = i;
2917 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2918 * @param v VC1Context
2919 * @param block block to decode
2920 * @param[in] n subblock index
2921 * @param coded are AC coeffs present or not
2922 * @param mquant block quantizer
2923 * @param codingset set of VLC to decode data
2925 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
2926 int coded, int mquant, int codingset)
2928 GetBitContext *gb = &v->s.gb;
2929 MpegEncContext *s = &v->s;
2930 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2933 int16_t *ac_val, *ac_val2;
2935 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2936 int a_avail = v->a_avail, c_avail = v->c_avail;
2937 int use_pred = s->ac_pred;
2941 s->dsp.clear_block(block);
2943 /* XXX: Guard against dumb values of mquant */
2944 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2946 /* Set DC scale - y and c use the same */
2947 s->y_dc_scale = s->y_dc_scale_table[mquant];
2948 s->c_dc_scale = s->c_dc_scale_table[mquant];
2950 /* Get DC differential */
2952 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2954 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2957 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2961 if (dcdiff == 119 /* ESC index value */) {
2962 /* TODO: Optimize */
2963 if (mquant == 1) dcdiff = get_bits(gb, 10);
2964 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2965 else dcdiff = get_bits(gb, 8);
2968 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2969 else if (mquant == 2)
2970 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2977 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2980 /* Store the quantized DC coeff, used for prediction */
2983 block[0] = dcdiff * s->y_dc_scale;
2985 block[0] = dcdiff * s->c_dc_scale;
2991 /* check if AC is needed at all and adjust direction if needed */
2992 if (!a_avail) dc_pred_dir = 1;
2993 if (!c_avail) dc_pred_dir = 0;
2994 if (!a_avail && !c_avail) use_pred = 0;
2995 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2998 scale = mquant * 2 + v->halfpq;
3000 if (dc_pred_dir) //left
3003 ac_val -= 16 * s->block_wrap[n];
3005 q1 = s->current_picture.f.qscale_table[mb_pos];
3006 if (dc_pred_dir && c_avail && mb_pos)
3007 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
3008 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3009 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
3010 if ( dc_pred_dir && n == 1)
3012 if (!dc_pred_dir && n == 2)
3014 if (n == 3) q2 = q1;
3017 int last = 0, skip, value;
3021 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3025 if (v->fcm == PROGRESSIVE)
3026 block[v->zz_8x8[0][i++]] = value;
3028 if (use_pred && (v->fcm == ILACE_FRAME)) {
3029 if (!dc_pred_dir) // top
3030 block[v->zz_8x8[2][i++]] = value;
3032 block[v->zz_8x8[3][i++]] = value;
3034 block[v->zzi_8x8[i++]] = value;
3039 /* apply AC prediction if needed */
3041 /* scale predictors if needed*/
3042 if (q2 && q1 != q2) {
3043 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3044 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3047 return AVERROR_INVALIDDATA;
3048 if (dc_pred_dir) { // left
3049 for (k = 1; k < 8; k++)
3050 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3052 for (k = 1; k < 8; k++)
3053 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3056 if (dc_pred_dir) { // left
3057 for (k = 1; k < 8; k++)
3058 block[k << v->left_blk_sh] += ac_val[k];
3060 for (k = 1; k < 8; k++)
3061 block[k << v->top_blk_sh] += ac_val[k + 8];
3065 /* save AC coeffs for further prediction */
3066 for (k = 1; k < 8; k++) {
3067 ac_val2[k ] = block[k << v->left_blk_sh];
3068 ac_val2[k + 8] = block[k << v->top_blk_sh];
3071 /* scale AC coeffs */
3072 for (k = 1; k < 64; k++)
3076 block[k] += (block[k] < 0) ? -mquant : mquant;
3079 if (use_pred) i = 63;
3080 } else { // no AC coeffs
3083 memset(ac_val2, 0, 16 * 2);
3084 if (dc_pred_dir) { // left
3086 memcpy(ac_val2, ac_val, 8 * 2);
3087 if (q2 && q1 != q2) {
3088 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3089 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3091 return AVERROR_INVALIDDATA;
3092 for (k = 1; k < 8; k++)
3093 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3098 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3099 if (q2 && q1 != q2) {
3100 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3101 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3103 return AVERROR_INVALIDDATA;
3104 for (k = 1; k < 8; k++)
3105 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3110 /* apply AC prediction if needed */
3112 if (dc_pred_dir) { // left
3113 for (k = 1; k < 8; k++) {
3114 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3115 if (!v->pquantizer && block[k << v->left_blk_sh])
3116 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3119 for (k = 1; k < 8; k++) {
3120 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3121 if (!v->pquantizer && block[k << v->top_blk_sh])
3122 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3128 s->block_last_index[n] = i;
3135 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
3136 int mquant, int ttmb, int first_block,
3137 uint8_t *dst, int linesize, int skip_block,
3140 MpegEncContext *s = &v->s;
3141 GetBitContext *gb = &s->gb;
3144 int scale, off, idx, last, skip, value;
3145 int ttblk = ttmb & 7;
3148 s->dsp.clear_block(block);
3151 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)];
3153 if (ttblk == TT_4X4) {
3154 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3156 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3157 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3158 || (!v->res_rtm_flag && !first_block))) {
3159 subblkpat = decode012(gb);
3161 subblkpat ^= 3; // swap decoded pattern bits
3162 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3164 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3167 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3169 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3170 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3171 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3174 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3175 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3184 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3189 idx = v->zz_8x8[0][i++];
3191 idx = v->zzi_8x8[i++];
3192 block[idx] = value * scale;
3194 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3198 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3200 v->vc1dsp.vc1_inv_trans_8x8(block);
3201 s->dsp.add_pixels_clamped(block, dst, linesize);
3206 pat = ~subblkpat & 0xF;
3207 for (j = 0; j < 4; j++) {
3208 last = subblkpat & (1 << (3 - j));
3210 off = (j & 1) * 4 + (j & 2) * 16;
3212 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3217 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3219 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3220 block[idx + off] = value * scale;
3222 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3224 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3226 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3228 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3233 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3234 for (j = 0; j < 2; j++) {
3235 last = subblkpat & (1 << (1 - j));
3239 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3244 idx = v->zz_8x4[i++] + off;
3246 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3247 block[idx] = value * scale;
3249 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3251 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3253 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3255 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3260 pat = ~(subblkpat * 5) & 0xF;
3261 for (j = 0; j < 2; j++) {
3262 last = subblkpat & (1 << (1 - j));
3266 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3271 idx = v->zz_4x8[i++] + off;
3273 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3274 block[idx] = value * scale;
3276 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3278 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3280 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3282 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3288 *ttmb_out |= ttblk << (n * 4);
3292 /** @} */ // Macroblock group
3294 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3295 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3297 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3299 MpegEncContext *s = &v->s;
3300 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3301 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3302 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3303 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3304 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3307 if (block_num > 3) {
3308 dst = s->dest[block_num - 3];
3310 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3312 if (s->mb_y != s->end_mb_y || block_num < 2) {
3316 if (block_num > 3) {
3317 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3318 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3319 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3320 mv_stride = s->mb_stride;
3322 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3323 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3324 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3325 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3326 mv_stride = s->b8_stride;
3327 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3330 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3331 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3332 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3334 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3336 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3339 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3341 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3346 dst -= 4 * linesize;
3347 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3348 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3349 idx = (block_cbp | (block_cbp >> 2)) & 3;
3351 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3354 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3356 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3361 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3363 MpegEncContext *s = &v->s;
3364 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3365 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3366 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3367 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3368 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3371 if (block_num > 3) {
3372 dst = s->dest[block_num - 3] - 8 * linesize;
3374 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3377 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3380 if (block_num > 3) {
3381 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3382 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3383 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3385 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3386 : (mb_cbp >> ((block_num + 1) * 4));
3387 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3388 : (mb_is_intra >> ((block_num + 1) * 4));
3389 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3391 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3392 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3394 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3396 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3399 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3401 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3407 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3408 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3409 idx = (block_cbp | (block_cbp >> 1)) & 5;
3411 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3414 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3416 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3421 static void vc1_apply_p_loop_filter(VC1Context *v)
3423 MpegEncContext *s = &v->s;
3426 for (i = 0; i < 6; i++) {
3427 vc1_apply_p_v_loop_filter(v, i);
3430 /* V always precedes H, therefore we run H one MB before V;
3431 * at the end of a row, we catch up to complete the row */
3433 for (i = 0; i < 6; i++) {
3434 vc1_apply_p_h_loop_filter(v, i);
3436 if (s->mb_x == s->mb_width - 1) {
3438 ff_update_block_index(s);
3439 for (i = 0; i < 6; i++) {
3440 vc1_apply_p_h_loop_filter(v, i);
3446 /** Decode one P-frame MB
3448 static int vc1_decode_p_mb(VC1Context *v)
3450 MpegEncContext *s = &v->s;
3451 GetBitContext *gb = &s->gb;
3453 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3454 int cbp; /* cbp decoding stuff */
3455 int mqdiff, mquant; /* MB quantization */
3456 int ttmb = v->ttfrm; /* MB Transform type */
3458 int mb_has_coeffs = 1; /* last_flag */
3459 int dmv_x, dmv_y; /* Differential MV components */
3460 int index, index1; /* LUT indexes */
3461 int val, sign; /* temp values */
3462 int first_block = 1;
3464 int skipped, fourmv;
3465 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3467 mquant = v->pq; /* lossy initialization */
3469 if (v->mv_type_is_raw)
3470 fourmv = get_bits1(gb);
3472 fourmv = v->mv_type_mb_plane[mb_pos];
3474 skipped = get_bits1(gb);
3476 skipped = v->s.mbskip_table[mb_pos];
3478 if (!fourmv) { /* 1MV mode */
3480 GET_MVDATA(dmv_x, dmv_y);
3483 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3484 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3486 s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3487 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3489 /* FIXME Set DC val for inter block ? */
3490 if (s->mb_intra && !mb_has_coeffs) {
3492 s->ac_pred = get_bits1(gb);
3494 } else if (mb_has_coeffs) {
3496 s->ac_pred = get_bits1(gb);
3497 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3503 s->current_picture.f.qscale_table[mb_pos] = mquant;
3505 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3506 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3507 VC1_TTMB_VLC_BITS, 2);
3508 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3510 for (i = 0; i < 6; i++) {
3511 s->dc_val[0][s->block_index[i]] = 0;
3513 val = ((cbp >> (5 - i)) & 1);
3514 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3515 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3517 /* check if prediction blocks A and C are available */
3518 v->a_avail = v->c_avail = 0;
3519 if (i == 2 || i == 3 || !s->first_slice_line)
3520 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3521 if (i == 1 || i == 3 || s->mb_x)
3522 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3524 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3525 (i & 4) ? v->codingset2 : v->codingset);
3526 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3528 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3530 for (j = 0; j < 64; j++)
3531 s->block[i][j] <<= 1;
3532 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3533 if (v->pq >= 9 && v->overlap) {
3535 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3537 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3539 block_cbp |= 0xF << (i << 2);
3540 block_intra |= 1 << i;
3542 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3543 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3544 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3545 block_cbp |= pat << (i << 2);
3546 if (!v->ttmbf && ttmb < 8)
3553 for (i = 0; i < 6; i++) {
3554 v->mb_type[0][s->block_index[i]] = 0;
3555 s->dc_val[0][s->block_index[i]] = 0;
3557 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3558 s->current_picture.f.qscale_table[mb_pos] = 0;
3559 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3562 } else { // 4MV mode
3563 if (!skipped /* unskipped MB */) {
3564 int intra_count = 0, coded_inter = 0;
3565 int is_intra[6], is_coded[6];
3567 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3568 for (i = 0; i < 6; i++) {
3569 val = ((cbp >> (5 - i)) & 1);
3570 s->dc_val[0][s->block_index[i]] = 0;
3577 GET_MVDATA(dmv_x, dmv_y);
3579 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3581 vc1_mc_4mv_luma(v, i, 0);
3582 intra_count += s->mb_intra;
3583 is_intra[i] = s->mb_intra;
3584 is_coded[i] = mb_has_coeffs;
3587 is_intra[i] = (intra_count >= 3);
3591 vc1_mc_4mv_chroma(v, 0);
3592 v->mb_type[0][s->block_index[i]] = is_intra[i];
3594 coded_inter = !is_intra[i] & is_coded[i];
3596 // if there are no coded blocks then don't do anything more
3598 if (!intra_count && !coded_inter)
3601 s->current_picture.f.qscale_table[mb_pos] = mquant;
3602 /* test if block is intra and has pred */
3605 for (i = 0; i < 6; i++)
3607 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3608 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3614 s->ac_pred = get_bits1(gb);
3618 if (!v->ttmbf && coded_inter)
3619 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3620 for (i = 0; i < 6; i++) {
3622 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3623 s->mb_intra = is_intra[i];
3625 /* check if prediction blocks A and C are available */
3626 v->a_avail = v->c_avail = 0;
3627 if (i == 2 || i == 3 || !s->first_slice_line)
3628 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3629 if (i == 1 || i == 3 || s->mb_x)
3630 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3632 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3633 (i & 4) ? v->codingset2 : v->codingset);
3634 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3636 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3638 for (j = 0; j < 64; j++)
3639 s->block[i][j] <<= 1;
3640 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3641 (i & 4) ? s->uvlinesize : s->linesize);
3642 if (v->pq >= 9 && v->overlap) {
3644 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3646 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3648 block_cbp |= 0xF << (i << 2);
3649 block_intra |= 1 << i;
3650 } else if (is_coded[i]) {
3651 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3652 first_block, s->dest[dst_idx] + off,
3653 (i & 4) ? s->uvlinesize : s->linesize,
3654 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3656 block_cbp |= pat << (i << 2);
3657 if (!v->ttmbf && ttmb < 8)
3662 } else { // skipped MB
3664 s->current_picture.f.qscale_table[mb_pos] = 0;
3665 for (i = 0; i < 6; i++) {
3666 v->mb_type[0][s->block_index[i]] = 0;
3667 s->dc_val[0][s->block_index[i]] = 0;
3669 for (i = 0; i < 4; i++) {
3670 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3671 vc1_mc_4mv_luma(v, i, 0);
3673 vc1_mc_4mv_chroma(v, 0);
3674 s->current_picture.f.qscale_table[mb_pos] = 0;
3678 v->cbp[s->mb_x] = block_cbp;
3679 v->ttblk[s->mb_x] = block_tt;
3680 v->is_intra[s->mb_x] = block_intra;
3685 /* Decode one macroblock in an interlaced frame p picture */
3687 static int vc1_decode_p_mb_intfr(VC1Context *v)
3689 MpegEncContext *s = &v->s;
3690 GetBitContext *gb = &s->gb;
3692 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3693 int cbp = 0; /* cbp decoding stuff */
3694 int mqdiff, mquant; /* MB quantization */
3695 int ttmb = v->ttfrm; /* MB Transform type */
3697 int mb_has_coeffs = 1; /* last_flag */
3698 int dmv_x, dmv_y; /* Differential MV components */
3699 int val; /* temp value */
3700 int first_block = 1;
3702 int skipped, fourmv = 0, twomv = 0;
3703 int block_cbp = 0, pat, block_tt = 0;
3704 int idx_mbmode = 0, mvbp;
3705 int stride_y, fieldtx;
3707 mquant = v->pq; /* Lossy initialization */
3710 skipped = get_bits1(gb);
3712 skipped = v->s.mbskip_table[mb_pos];
3714 if (v->fourmvswitch)
3715 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3717 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3718 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3719 /* store the motion vector type in a flag (useful later) */
3720 case MV_PMODE_INTFR_4MV:
3722 v->blk_mv_type[s->block_index[0]] = 0;
3723 v->blk_mv_type[s->block_index[1]] = 0;
3724 v->blk_mv_type[s->block_index[2]] = 0;
3725 v->blk_mv_type[s->block_index[3]] = 0;
3727 case MV_PMODE_INTFR_4MV_FIELD:
3729 v->blk_mv_type[s->block_index[0]] = 1;
3730 v->blk_mv_type[s->block_index[1]] = 1;
3731 v->blk_mv_type[s->block_index[2]] = 1;
3732 v->blk_mv_type[s->block_index[3]] = 1;
3734 case MV_PMODE_INTFR_2MV_FIELD:
3736 v->blk_mv_type[s->block_index[0]] = 1;
3737 v->blk_mv_type[s->block_index[1]] = 1;
3738 v->blk_mv_type[s->block_index[2]] = 1;
3739 v->blk_mv_type[s->block_index[3]] = 1;
3741 case MV_PMODE_INTFR_1MV:
3742 v->blk_mv_type[s->block_index[0]] = 0;
3743 v->blk_mv_type[s->block_index[1]] = 0;
3744 v->blk_mv_type[s->block_index[2]] = 0;
3745 v->blk_mv_type[s->block_index[3]] = 0;
3748 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3749 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3750 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3751 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
3752 s->mb_intra = v->is_intra[s->mb_x] = 1;
3753 for (i = 0; i < 6; i++)
3754 v->mb_type[0][s->block_index[i]] = 1;
3755 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3756 mb_has_coeffs = get_bits1(gb);
3758 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3759 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3761 s->current_picture.f.qscale_table[mb_pos] = mquant;
3762 /* Set DC scale - y and c use the same (not sure if necessary here) */
3763 s->y_dc_scale = s->y_dc_scale_table[mquant];
3764 s->c_dc_scale = s->c_dc_scale_table[mquant];
3766 for (i = 0; i < 6; i++) {
3767 s->dc_val[0][s->block_index[i]] = 0;
3769 val = ((cbp >> (5 - i)) & 1);
3770 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3771 v->a_avail = v->c_avail = 0;
3772 if (i == 2 || i == 3 || !s->first_slice_line)
3773 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3774 if (i == 1 || i == 3 || s->mb_x)
3775 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3777 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3778 (i & 4) ? v->codingset2 : v->codingset);
3779 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3780 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3782 stride_y = s->linesize << fieldtx;
3783 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3785 stride_y = s->uvlinesize;
3788 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3792 } else { // inter MB
3793 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3795 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3796 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3797 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3799 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3800 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3801 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3804 s->mb_intra = v->is_intra[s->mb_x] = 0;
3805 for (i = 0; i < 6; i++)
3806 v->mb_type[0][s->block_index[i]] = 0;
3807 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3808 /* for all motion vector read MVDATA and motion compensate each block */
3812 for (i = 0; i < 6; i++) {
3815 val = ((mvbp >> (3 - i)) & 1);
3817 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3819 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3820 vc1_mc_4mv_luma(v, i, 0);
3821 } else if (i == 4) {
3822 vc1_mc_4mv_chroma4(v);
3829 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3831 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3832 vc1_mc_4mv_luma(v, 0, 0);
3833 vc1_mc_4mv_luma(v, 1, 0);
3836 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3838 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3839 vc1_mc_4mv_luma(v, 2, 0);
3840 vc1_mc_4mv_luma(v, 3, 0);
3841 vc1_mc_4mv_chroma4(v);
3843 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3846 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3848 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3852 GET_MQUANT(); // p. 227
3853 s->current_picture.f.qscale_table[mb_pos] = mquant;
3854 if (!v->ttmbf && cbp)
3855 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3856 for (i = 0; i < 6; i++) {
3857 s->dc_val[0][s->block_index[i]] = 0;
3859 val = ((cbp >> (5 - i)) & 1);
3861 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3863 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3865 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3866 first_block, s->dest[dst_idx] + off,
3867 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3868 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3869 block_cbp |= pat << (i << 2);
3870 if (!v->ttmbf && ttmb < 8)
3877 s->mb_intra = v->is_intra[s->mb_x] = 0;
3878 for (i = 0; i < 6; i++) {
3879 v->mb_type[0][s->block_index[i]] = 0;
3880 s->dc_val[0][s->block_index[i]] = 0;
3882 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3883 s->current_picture.f.qscale_table[mb_pos] = 0;
3884 v->blk_mv_type[s->block_index[0]] = 0;
3885 v->blk_mv_type[s->block_index[1]] = 0;
3886 v->blk_mv_type[s->block_index[2]] = 0;
3887 v->blk_mv_type[s->block_index[3]] = 0;
3888 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3891 if (s->mb_x == s->mb_width - 1)
3892 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3896 static int vc1_decode_p_mb_intfi(VC1Context *v)
3898 MpegEncContext *s = &v->s;
3899 GetBitContext *gb = &s->gb;
3901 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3902 int cbp = 0; /* cbp decoding stuff */
3903 int mqdiff, mquant; /* MB quantization */
3904 int ttmb = v->ttfrm; /* MB Transform type */
3906 int mb_has_coeffs = 1; /* last_flag */
3907 int dmv_x, dmv_y; /* Differential MV components */
3908 int val; /* temp values */
3909 int first_block = 1;
3912 int block_cbp = 0, pat, block_tt = 0;
3915 mquant = v->pq; /* Lossy initialization */
3917 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3918 if (idx_mbmode <= 1) { // intra MB
3919 s->mb_intra = v->is_intra[s->mb_x] = 1;
3920 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3921 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3922 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3924 s->current_picture.f.qscale_table[mb_pos] = mquant;
3925 /* Set DC scale - y and c use the same (not sure if necessary here) */
3926 s->y_dc_scale = s->y_dc_scale_table[mquant];
3927 s->c_dc_scale = s->c_dc_scale_table[mquant];
3928 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3929 mb_has_coeffs = idx_mbmode & 1;
3931 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3933 for (i = 0; i < 6; i++) {
3934 s->dc_val[0][s->block_index[i]] = 0;
3935 v->mb_type[0][s->block_index[i]] = 1;
3937 val = ((cbp >> (5 - i)) & 1);
3938 v->a_avail = v->c_avail = 0;
3939 if (i == 2 || i == 3 || !s->first_slice_line)
3940 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3941 if (i == 1 || i == 3 || s->mb_x)
3942 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3944 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3945 (i & 4) ? v->codingset2 : v->codingset);
3946 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3948 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3949 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3950 off += v->second_field ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
3951 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
3952 // TODO: loop filter
3955 s->mb_intra = v->is_intra[s->mb_x] = 0;
3956 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3957 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3958 if (idx_mbmode <= 5) { // 1-MV
3960 if (idx_mbmode & 1) {
3961 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3963 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3965 mb_has_coeffs = !(idx_mbmode & 2);
3967 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3968 for (i = 0; i < 6; i++) {
3970 dmv_x = dmv_y = pred_flag = 0;
3971 val = ((v->fourmvbp >> (3 - i)) & 1);
3973 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3975 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3976 vc1_mc_4mv_luma(v, i, 0);
3978 vc1_mc_4mv_chroma(v, 0);
3980 mb_has_coeffs = idx_mbmode & 1;
3983 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3987 s->current_picture.f.qscale_table[mb_pos] = mquant;
3988 if (!v->ttmbf && cbp) {
3989 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3992 for (i = 0; i < 6; i++) {
3993 s->dc_val[0][s->block_index[i]] = 0;
3995 val = ((cbp >> (5 - i)) & 1);
3996 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
3997 if (v->second_field)
3998 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4000 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4001 first_block, s->dest[dst_idx] + off,
4002 (i & 4) ? s->uvlinesize : s->linesize,
4003 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
4005 block_cbp |= pat << (i << 2);
4006 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4011 if (s->mb_x == s->mb_width - 1)
4012 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4016 /** Decode one B-frame MB (in Main profile)
4018 static void vc1_decode_b_mb(VC1Context *v)
4020 MpegEncContext *s = &v->s;
4021 GetBitContext *gb = &s->gb;
4023 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4024 int cbp = 0; /* cbp decoding stuff */
4025 int mqdiff, mquant; /* MB quantization */
4026 int ttmb = v->ttfrm; /* MB Transform type */
4027 int mb_has_coeffs = 0; /* last_flag */
4028 int index, index1; /* LUT indexes */
4029 int val, sign; /* temp values */
4030 int first_block = 1;
4032 int skipped, direct;
4033 int dmv_x[2], dmv_y[2];
4034 int bmvtype = BMV_TYPE_BACKWARD;
4036 mquant = v->pq; /* lossy initialization */
4040 direct = get_bits1(gb);
4042 direct = v->direct_mb_plane[mb_pos];
4044 skipped = get_bits1(gb);
4046 skipped = v->s.mbskip_table[mb_pos];
4048 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4049 for (i = 0; i < 6; i++) {
4050 v->mb_type[0][s->block_index[i]] = 0;
4051 s->dc_val[0][s->block_index[i]] = 0;
4053 s->current_picture.f.qscale_table[mb_pos] = 0;
4057 GET_MVDATA(dmv_x[0], dmv_y[0]);
4058 dmv_x[1] = dmv_x[0];
4059 dmv_y[1] = dmv_y[0];
4061 if (skipped || !s->mb_intra) {
4062 bmvtype = decode012(gb);
4065 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4068 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4071 bmvtype = BMV_TYPE_INTERPOLATED;
4072 dmv_x[0] = dmv_y[0] = 0;
4076 for (i = 0; i < 6; i++)
4077 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4081 bmvtype = BMV_TYPE_INTERPOLATED;
4082 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4083 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4087 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4090 s->current_picture.f.qscale_table[mb_pos] = mquant;
4092 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4093 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4094 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4095 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4097 if (!mb_has_coeffs && !s->mb_intra) {
4098 /* no coded blocks - effectively skipped */
4099 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4100 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4103 if (s->mb_intra && !mb_has_coeffs) {
4105 s->current_picture.f.qscale_table[mb_pos] = mquant;
4106 s->ac_pred = get_bits1(gb);
4108 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4110 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4111 GET_MVDATA(dmv_x[0], dmv_y[0]);
4112 if (!mb_has_coeffs) {
4113 /* interpolated skipped block */
4114 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4115 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4119 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4121 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4124 s->ac_pred = get_bits1(gb);
4125 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4127 s->current_picture.f.qscale_table[mb_pos] = mquant;
4128 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4129 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4133 for (i = 0; i < 6; i++) {
4134 s->dc_val[0][s->block_index[i]] = 0;
4136 val = ((cbp >> (5 - i)) & 1);
4137 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4138 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4140 /* check if prediction blocks A and C are available */
4141 v->a_avail = v->c_avail = 0;
4142 if (i == 2 || i == 3 || !s->first_slice_line)
4143 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4144 if (i == 1 || i == 3 || s->mb_x)
4145 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4147 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4148 (i & 4) ? v->codingset2 : v->codingset);
4149 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4151 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4153 for (j = 0; j < 64; j++)
4154 s->block[i][j] <<= 1;
4155 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4157 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4158 first_block, s->dest[dst_idx] + off,
4159 (i & 4) ? s->uvlinesize : s->linesize,
4160 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4161 if (!v->ttmbf && ttmb < 8)
4168 /** Decode one B-frame MB (in interlaced field B picture)
4170 static void vc1_decode_b_mb_intfi(VC1Context *v)
4172 MpegEncContext *s = &v->s;
4173 GetBitContext *gb = &s->gb;
4175 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4176 int cbp = 0; /* cbp decoding stuff */
4177 int mqdiff, mquant; /* MB quantization */
4178 int ttmb = v->ttfrm; /* MB Transform type */
4179 int mb_has_coeffs = 0; /* last_flag */
4180 int val; /* temp value */
4181 int first_block = 1;
4184 int dmv_x[2], dmv_y[2], pred_flag[2];
4185 int bmvtype = BMV_TYPE_BACKWARD;
4186 int idx_mbmode, interpmvp;
4188 mquant = v->pq; /* Lossy initialization */
4191 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4192 if (idx_mbmode <= 1) { // intra MB
4193 s->mb_intra = v->is_intra[s->mb_x] = 1;
4194 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4195 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4196 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4198 s->current_picture.f.qscale_table[mb_pos] = mquant;
4199 /* Set DC scale - y and c use the same (not sure if necessary here) */
4200 s->y_dc_scale = s->y_dc_scale_table[mquant];
4201 s->c_dc_scale = s->c_dc_scale_table[mquant];
4202 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4203 mb_has_coeffs = idx_mbmode & 1;
4205 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4207 for (i = 0; i < 6; i++) {
4208 s->dc_val[0][s->block_index[i]] = 0;
4210 val = ((cbp >> (5 - i)) & 1);
4211 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4212 v->a_avail = v->c_avail = 0;
4213 if (i == 2 || i == 3 || !s->first_slice_line)
4214 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4215 if (i == 1 || i == 3 || s->mb_x)
4216 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4218 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4219 (i & 4) ? v->codingset2 : v->codingset);
4220 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4222 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4224 for (j = 0; j < 64; j++)
4225 s->block[i][j] <<= 1;
4226 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4227 off += v->second_field ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4228 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4229 // TODO: yet to perform loop filter
4232 s->mb_intra = v->is_intra[s->mb_x] = 0;
4233 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4234 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4236 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4238 fwd = v->forward_mb_plane[mb_pos];
4239 if (idx_mbmode <= 5) { // 1-MV
4240 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4241 pred_flag[0] = pred_flag[1] = 0;
4243 bmvtype = BMV_TYPE_FORWARD;
4245 bmvtype = decode012(gb);
4248 bmvtype = BMV_TYPE_BACKWARD;
4251 bmvtype = BMV_TYPE_DIRECT;
4254 bmvtype = BMV_TYPE_INTERPOLATED;
4255 interpmvp = get_bits1(gb);
4258 v->bmvtype = bmvtype;
4259 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4260 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4262 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4263 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4265 if (bmvtype == BMV_TYPE_DIRECT) {
4266 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4267 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4269 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4270 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4271 mb_has_coeffs = !(idx_mbmode & 2);
4274 bmvtype = BMV_TYPE_FORWARD;
4275 v->bmvtype = bmvtype;
4276 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4277 for (i = 0; i < 6; i++) {
4279 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4280 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4281 val = ((v->fourmvbp >> (3 - i)) & 1);
4283 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4284 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4285 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4287 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4288 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4290 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4292 mb_has_coeffs = idx_mbmode & 1;
4295 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4299 s->current_picture.f.qscale_table[mb_pos] = mquant;
4300 if (!v->ttmbf && cbp) {
4301 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4304 for (i = 0; i < 6; i++) {
4305 s->dc_val[0][s->block_index[i]] = 0;
4307 val = ((cbp >> (5 - i)) & 1);
4308 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4309 if (v->second_field)
4310 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4312 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4313 first_block, s->dest[dst_idx] + off,
4314 (i & 4) ? s->uvlinesize : s->linesize,
4315 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4316 if (!v->ttmbf && ttmb < 8)
4324 /** Decode blocks of I-frame
4326 static void vc1_decode_i_blocks(VC1Context *v)
4329 MpegEncContext *s = &v->s;
4334 /* select codingmode used for VLC tables selection */
4335 switch (v->y_ac_table_index) {
4337 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4340 v->codingset = CS_HIGH_MOT_INTRA;
4343 v->codingset = CS_MID_RATE_INTRA;
4347 switch (v->c_ac_table_index) {
4349 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4352 v->codingset2 = CS_HIGH_MOT_INTER;
4355 v->codingset2 = CS_MID_RATE_INTER;
4359 /* Set DC scale - y and c use the same */
4360 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4361 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4364 s->mb_x = s->mb_y = 0;
4366 s->first_slice_line = 1;
4367 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4369 ff_init_block_index(s);
4370 for (; s->mb_x < s->mb_width; s->mb_x++) {
4372 ff_update_block_index(s);
4373 dst[0] = s->dest[0];
4374 dst[1] = dst[0] + 8;
4375 dst[2] = s->dest[0] + s->linesize * 8;
4376 dst[3] = dst[2] + 8;
4377 dst[4] = s->dest[1];
4378 dst[5] = s->dest[2];
4379 s->dsp.clear_blocks(s->block[0]);
4380 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4381 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
4382 s->current_picture.f.qscale_table[mb_pos] = v->pq;
4383 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4384 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4386 // do actual MB decoding and displaying
4387 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4388 v->s.ac_pred = get_bits1(&v->s.gb);
4390 for (k = 0; k < 6; k++) {
4391 val = ((cbp >> (5 - k)) & 1);
4394 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4398 cbp |= val << (5 - k);
4400 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4402 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4404 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4405 if (v->pq >= 9 && v->overlap) {
4407 for (j = 0; j < 64; j++)
4408 s->block[k][j] <<= 1;
4409 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4412 for (j = 0; j < 64; j++)
4413 s->block[k][j] = (s->block[k][j] - 64) << 1;
4414 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4418 if (v->pq >= 9 && v->overlap) {
4420 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4421 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4422 if (!(s->flags & CODEC_FLAG_GRAY)) {
4423 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4424 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4427 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4428 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4429 if (!s->first_slice_line) {
4430 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4431 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4432 if (!(s->flags & CODEC_FLAG_GRAY)) {
4433 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4434 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4437 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4438 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4440 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4442 if (get_bits_count(&s->gb) > v->bits) {
4443 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4444 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4445 get_bits_count(&s->gb), v->bits);
4449 if (!v->s.loop_filter)
4450 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4452 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4454 s->first_slice_line = 0;
4456 if (v->s.loop_filter)
4457 ff_draw_horiz_band(s, (s->mb_height - 1) * 16, 16);
4458 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4461 /** Decode blocks of I-frame for advanced profile
4463 static void vc1_decode_i_blocks_adv(VC1Context *v)
4466 MpegEncContext *s = &v->s;
4472 GetBitContext *gb = &s->gb;
4474 /* select codingmode used for VLC tables selection */
4475 switch (v->y_ac_table_index) {
4477 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4480 v->codingset = CS_HIGH_MOT_INTRA;
4483 v->codingset = CS_MID_RATE_INTRA;
4487 switch (v->c_ac_table_index) {
4489 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4492 v->codingset2 = CS_HIGH_MOT_INTER;
4495 v->codingset2 = CS_MID_RATE_INTER;
4500 s->mb_x = s->mb_y = 0;
4502 s->first_slice_line = 1;
4503 s->mb_y = s->start_mb_y;
4504 if (s->start_mb_y) {
4506 ff_init_block_index(s);
4507 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4508 (1 + s->b8_stride) * sizeof(*s->coded_block));
4510 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4512 ff_init_block_index(s);
4513 for (;s->mb_x < s->mb_width; s->mb_x++) {
4514 DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
4515 ff_update_block_index(s);
4516 s->dsp.clear_blocks(block[0]);
4517 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4518 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4519 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4520 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4522 // do actual MB decoding and displaying
4523 if (v->fieldtx_is_raw)
4524 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4525 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4526 if ( v->acpred_is_raw)
4527 v->s.ac_pred = get_bits1(&v->s.gb);
4529 v->s.ac_pred = v->acpred_plane[mb_pos];
4531 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4532 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4536 s->current_picture.f.qscale_table[mb_pos] = mquant;
4537 /* Set DC scale - y and c use the same */
4538 s->y_dc_scale = s->y_dc_scale_table[mquant];
4539 s->c_dc_scale = s->c_dc_scale_table[mquant];
4541 for (k = 0; k < 6; k++) {
4542 val = ((cbp >> (5 - k)) & 1);
4545 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4549 cbp |= val << (5 - k);
4551 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4552 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4554 vc1_decode_i_block_adv(v, block[k], k, val,
4555 (k < 4) ? v->codingset : v->codingset2, mquant);
4557 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4559 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4562 vc1_smooth_overlap_filter_iblk(v);
4563 vc1_put_signed_blocks_clamped(v);
4564 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4566 if (get_bits_count(&s->gb) > v->bits) {
4567 // TODO: may need modification to handle slice coding
4568 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4569 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4570 get_bits_count(&s->gb), v->bits);
4574 if (!v->s.loop_filter)
4575 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4577 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4578 s->first_slice_line = 0;
4581 /* raw bottom MB row */
4583 ff_init_block_index(s);
4584 for (;s->mb_x < s->mb_width; s->mb_x++) {
4585 ff_update_block_index(s);
4586 vc1_put_signed_blocks_clamped(v);
4587 if (v->s.loop_filter)
4588 vc1_loop_filter_iblk_delayed(v, v->pq);
4590 if (v->s.loop_filter)
4591 ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4592 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4593 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4596 static void vc1_decode_p_blocks(VC1Context *v)
4598 MpegEncContext *s = &v->s;
4599 int apply_loop_filter;
4601 /* select codingmode used for VLC tables selection */
4602 switch (v->c_ac_table_index) {
4604 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4607 v->codingset = CS_HIGH_MOT_INTRA;
4610 v->codingset = CS_MID_RATE_INTRA;
4614 switch (v->c_ac_table_index) {
4616 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4619 v->codingset2 = CS_HIGH_MOT_INTER;
4622 v->codingset2 = CS_MID_RATE_INTER;
4626 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
4627 s->first_slice_line = 1;
4628 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
4629 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4631 ff_init_block_index(s);
4632 for (; s->mb_x < s->mb_width; s->mb_x++) {
4633 ff_update_block_index(s);
4635 if (v->fcm == ILACE_FIELD)
4636 vc1_decode_p_mb_intfi(v);
4637 else if (v->fcm == ILACE_FRAME)
4638 vc1_decode_p_mb_intfr(v);
4639 else vc1_decode_p_mb(v);
4640 if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == PROGRESSIVE)
4641 vc1_apply_p_loop_filter(v);
4642 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4643 // TODO: may need modification to handle slice coding
4644 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4645 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4646 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4650 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
4651 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
4652 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4653 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
4654 if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4655 s->first_slice_line = 0;
4657 if (apply_loop_filter) {
4659 ff_init_block_index(s);
4660 for (; s->mb_x < s->mb_width; s->mb_x++) {
4661 ff_update_block_index(s);
4662 vc1_apply_p_loop_filter(v);
4665 if (s->end_mb_y >= s->start_mb_y)
4666 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4667 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4668 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4671 static void vc1_decode_b_blocks(VC1Context *v)
4673 MpegEncContext *s = &v->s;
4675 /* select codingmode used for VLC tables selection */
4676 switch (v->c_ac_table_index) {
4678 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4681 v->codingset = CS_HIGH_MOT_INTRA;
4684 v->codingset = CS_MID_RATE_INTRA;
4688 switch (v->c_ac_table_index) {
4690 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4693 v->codingset2 = CS_HIGH_MOT_INTER;
4696 v->codingset2 = CS_MID_RATE_INTER;
4700 s->first_slice_line = 1;
4701 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4703 ff_init_block_index(s);
4704 for (; s->mb_x < s->mb_width; s->mb_x++) {
4705 ff_update_block_index(s);
4707 if (v->fcm == ILACE_FIELD)
4708 vc1_decode_b_mb_intfi(v);
4711 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4712 // TODO: may need modification to handle slice coding
4713 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4714 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4715 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4718 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4720 if (!v->s.loop_filter)
4721 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4723 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4724 s->first_slice_line = 0;
4726 if (v->s.loop_filter)
4727 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4728 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4729 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4732 static void vc1_decode_skip_blocks(VC1Context *v)
4734 MpegEncContext *s = &v->s;
4736 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
4737 s->first_slice_line = 1;
4738 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4740 ff_init_block_index(s);
4741 ff_update_block_index(s);
4742 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4743 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4744 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4745 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4746 s->first_slice_line = 0;
4748 s->pict_type = AV_PICTURE_TYPE_P;
4751 static void vc1_decode_blocks(VC1Context *v)
4754 v->s.esc3_level_length = 0;
4756 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
4759 v->left_blk_idx = -1;
4760 v->topleft_blk_idx = 1;
4762 switch (v->s.pict_type) {
4763 case AV_PICTURE_TYPE_I:
4764 if (v->profile == PROFILE_ADVANCED)
4765 vc1_decode_i_blocks_adv(v);
4767 vc1_decode_i_blocks(v);
4769 case AV_PICTURE_TYPE_P:
4770 if (v->p_frame_skipped)
4771 vc1_decode_skip_blocks(v);
4773 vc1_decode_p_blocks(v);
4775 case AV_PICTURE_TYPE_B:
4777 if (v->profile == PROFILE_ADVANCED)
4778 vc1_decode_i_blocks_adv(v);
4780 vc1_decode_i_blocks(v);
4782 vc1_decode_b_blocks(v);
4788 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
4792 * Transform coefficients for both sprites in 16.16 fixed point format,
4793 * in the order they appear in the bitstream:
4795 * rotation 1 (unused)
4797 * rotation 2 (unused)
4804 int effect_type, effect_flag;
4805 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
4806 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
4809 static inline int get_fp_val(GetBitContext* gb)
4811 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
4814 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
4818 switch (get_bits(gb, 2)) {
4821 c[2] = get_fp_val(gb);
4825 c[0] = c[4] = get_fp_val(gb);
4826 c[2] = get_fp_val(gb);
4829 c[0] = get_fp_val(gb);
4830 c[2] = get_fp_val(gb);
4831 c[4] = get_fp_val(gb);
4834 c[0] = get_fp_val(gb);
4835 c[1] = get_fp_val(gb);
4836 c[2] = get_fp_val(gb);
4837 c[3] = get_fp_val(gb);
4838 c[4] = get_fp_val(gb);
4841 c[5] = get_fp_val(gb);
4843 c[6] = get_fp_val(gb);
4848 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
4850 AVCodecContext *avctx = v->s.avctx;
4853 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4854 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
4855 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
4856 av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
4857 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
4858 for (i = 0; i < 7; i++)
4859 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
4860 sd->coefs[sprite][i] / (1<<16),
4861 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
4862 av_log(avctx, AV_LOG_DEBUG, "\n");
4866 if (sd->effect_type = get_bits_long(gb, 30)) {
4867 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
4869 vc1_sprite_parse_transform(gb, sd->effect_params1);
4872 vc1_sprite_parse_transform(gb, sd->effect_params1);
4873 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
4876 for (i = 0; i < sd->effect_pcount1; i++)
4877 sd->effect_params1[i] = get_fp_val(gb);
4879 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
4880 // effect 13 is simple alpha blending and matches the opacity above
4881 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
4882 for (i = 0; i < sd->effect_pcount1; i++)
4883 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4884 sd->effect_params1[i] / (1 << 16),
4885 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
4886 av_log(avctx, AV_LOG_DEBUG, "\n");
4889 sd->effect_pcount2 = get_bits(gb, 16);
4890 if (sd->effect_pcount2 > 10) {
4891 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
4893 } else if (sd->effect_pcount2) {
4895 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
4896 while (++i < sd->effect_pcount2) {
4897 sd->effect_params2[i] = get_fp_val(gb);
4898 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4899 sd->effect_params2[i] / (1 << 16),
4900 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
4902 av_log(avctx, AV_LOG_DEBUG, "\n");
4905 if (sd->effect_flag = get_bits1(gb))
4906 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4908 if (get_bits_count(gb) >= gb->size_in_bits +
4909 (avctx->codec_id == CODEC_ID_WMV3IMAGE ? 64 : 0))
4910 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4911 if (get_bits_count(gb) < gb->size_in_bits - 8)
4912 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4915 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
4917 int i, plane, row, sprite;
4918 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
4919 uint8_t* src_h[2][2];
4920 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
4922 MpegEncContext *s = &v->s;
4924 for (i = 0; i < 2; i++) {
4925 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
4926 xadv[i] = sd->coefs[i][0];
4927 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
4928 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
4930 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
4931 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
4933 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
4935 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
4936 int width = v->output_width>>!!plane;
4938 for (row = 0; row < v->output_height>>!!plane; row++) {
4939 uint8_t *dst = v->sprite_output_frame.data[plane] +
4940 v->sprite_output_frame.linesize[plane] * row;
4942 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4943 uint8_t *iplane = s->current_picture.f.data[plane];
4944 int iline = s->current_picture.f.linesize[plane];
4945 int ycoord = yoff[sprite] + yadv[sprite] * row;
4946 int yline = ycoord >> 16;
4947 ysub[sprite] = ycoord & 0xFFFF;
4949 iplane = s->last_picture.f.data[plane];
4950 iline = s->last_picture.f.linesize[plane];
4952 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4953 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
4955 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + FFMIN(yline + 1, (v->sprite_height>>!!plane)-1) * iline;
4957 if (sr_cache[sprite][0] != yline) {
4958 if (sr_cache[sprite][1] == yline) {
4959 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
4960 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
4962 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
4963 sr_cache[sprite][0] = yline;
4966 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4967 v->vc1dsp.sprite_h(v->sr_rows[sprite][1], iplane + FFMIN(yline + 1, (v->sprite_height>>!!plane)-1) * iline, xoff[sprite], xadv[sprite], width);
4968 sr_cache[sprite][1] = yline + 1;
4970 src_h[sprite][0] = v->sr_rows[sprite][0];
4971 src_h[sprite][1] = v->sr_rows[sprite][1];
4975 if (!v->two_sprites) {
4977 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
4979 memcpy(dst, src_h[0][0], width);
4982 if (ysub[0] && ysub[1]) {
4983 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
4984 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
4985 } else if (ysub[0]) {
4986 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
4987 src_h[1][0], alpha, width);
4988 } else if (ysub[1]) {
4989 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
4990 src_h[0][0], (1<<16)-1-alpha, width);
4992 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
4998 for (i = 0; i < 2; i++) {
5008 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5010 MpegEncContext *s = &v->s;
5011 AVCodecContext *avctx = s->avctx;
5014 vc1_parse_sprites(v, gb, &sd);
5016 if (!s->current_picture.f.data[0]) {
5017 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5021 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5022 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5026 if (v->sprite_output_frame.data[0])
5027 avctx->release_buffer(avctx, &v->sprite_output_frame);
5029 v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5030 v->sprite_output_frame.reference = 0;
5031 if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
5032 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5036 vc1_draw_sprites(v, &sd);
5041 static void vc1_sprite_flush(AVCodecContext *avctx)
5043 VC1Context *v = avctx->priv_data;
5044 MpegEncContext *s = &v->s;
5045 AVFrame *f = &s->current_picture.f;
5048 /* Windows Media Image codecs have a convergence interval of two keyframes.
5049 Since we can't enforce it, clear to black the missing sprite. This is
5050 wrong but it looks better than doing nothing. */
5053 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5054 for (i = 0; i < v->sprite_height>>!!plane; i++)
5055 memset(f->data[plane] + i * f->linesize[plane],
5056 plane ? 128 : 0, f->linesize[plane]);
5061 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
5063 MpegEncContext *s = &v->s;
5066 /* Allocate mb bitplanes */
5067 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5068 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5069 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5070 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5071 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5072 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5074 v->n_allocated_blks = s->mb_width + 2;
5075 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5076 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5077 v->cbp = v->cbp_base + s->mb_stride;
5078 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5079 v->ttblk = v->ttblk_base + s->mb_stride;
5080 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5081 v->is_intra = v->is_intra_base + s->mb_stride;
5082 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5083 v->luma_mv = v->luma_mv_base + s->mb_stride;
5085 /* allocate block type info in that way so it could be used with s->block_index[] */
5086 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5087 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5088 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5089 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5091 /* allocate memory to store block level MV info */
5092 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5093 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5094 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5095 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5096 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5097 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5098 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
5099 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);
5100 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5101 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5102 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);
5104 /* Init coded blocks info */
5105 if (v->profile == PROFILE_ADVANCED) {
5106 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5108 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5112 ff_intrax8_common_init(&v->x8,s);
5114 if (s->avctx->codec_id == CODEC_ID_WMV3IMAGE || s->avctx->codec_id == CODEC_ID_VC1IMAGE) {
5115 for (i = 0; i < 4; i++)
5116 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5119 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5120 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5127 /** Initialize a VC1/WMV3 decoder
5128 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5129 * @todo TODO: Decypher remaining bits in extra_data
5131 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5133 VC1Context *v = avctx->priv_data;
5134 MpegEncContext *s = &v->s;
5138 /* save the container output size for WMImage */
5139 v->output_width = avctx->width;
5140 v->output_height = avctx->height;
5142 if (!avctx->extradata_size || !avctx->extradata)
5144 if (!(avctx->flags & CODEC_FLAG_GRAY))
5145 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5147 avctx->pix_fmt = PIX_FMT_GRAY8;
5148 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5150 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5151 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5153 if (avctx->idct_algo == FF_IDCT_AUTO) {
5154 avctx->idct_algo = FF_IDCT_WMV2;
5157 if (ff_vc1_init_common(v) < 0)
5159 ff_vc1dsp_init(&v->vc1dsp);
5161 if (avctx->codec_id == CODEC_ID_WMV3 || avctx->codec_id == CODEC_ID_WMV3IMAGE) {
5164 // looks like WMV3 has a sequence header stored in the extradata
5165 // advanced sequence header may be before the first frame
5166 // the last byte of the extradata is a version number, 1 for the
5167 // samples we can decode
5169 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5171 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5174 count = avctx->extradata_size*8 - get_bits_count(&gb);
5176 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5177 count, get_bits(&gb, count));
5178 } else if (count < 0) {
5179 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5181 } else { // VC1/WVC1/WVP2
5182 const uint8_t *start = avctx->extradata;
5183 uint8_t *end = avctx->extradata + avctx->extradata_size;
5184 const uint8_t *next;
5185 int size, buf2_size;
5186 uint8_t *buf2 = NULL;
5187 int seq_initialized = 0, ep_initialized = 0;
5189 if (avctx->extradata_size < 16) {
5190 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5194 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5195 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5197 for (; next < end; start = next) {
5198 next = find_next_marker(start + 4, end);
5199 size = next - start - 4;
5202 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5203 init_get_bits(&gb, buf2, buf2_size * 8);
5204 switch (AV_RB32(start)) {
5205 case VC1_CODE_SEQHDR:
5206 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5210 seq_initialized = 1;
5212 case VC1_CODE_ENTRYPOINT:
5213 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5222 if (!seq_initialized || !ep_initialized) {
5223 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5226 v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
5229 avctx->profile = v->profile;
5230 if (v->profile == PROFILE_ADVANCED)
5231 avctx->level = v->level;
5233 avctx->has_b_frames = !!avctx->max_b_frames;
5235 s->mb_width = (avctx->coded_width + 15) >> 4;
5236 s->mb_height = (avctx->coded_height + 15) >> 4;
5238 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5239 for (i = 0; i < 64; i++) {
5240 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5241 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5242 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5243 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5244 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5245 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5250 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5255 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5256 v->sprite_width = avctx->coded_width;
5257 v->sprite_height = avctx->coded_height;
5259 avctx->coded_width = avctx->width = v->output_width;
5260 avctx->coded_height = avctx->height = v->output_height;
5262 // prevent 16.16 overflows
5263 if (v->sprite_width > 1 << 14 ||
5264 v->sprite_height > 1 << 14 ||
5265 v->output_width > 1 << 14 ||
5266 v->output_height > 1 << 14) return -1;
5271 /** Close a VC1/WMV3 decoder
5272 * @warning Initial try at using MpegEncContext stuff
5274 static av_cold int vc1_decode_end(AVCodecContext *avctx)
5276 VC1Context *v = avctx->priv_data;
5279 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
5280 && v->sprite_output_frame.data[0])
5281 avctx->release_buffer(avctx, &v->sprite_output_frame);
5282 for (i = 0; i < 4; i++)
5283 av_freep(&v->sr_rows[i >> 1][i & 1]);
5284 av_freep(&v->hrd_rate);
5285 av_freep(&v->hrd_buffer);
5286 ff_MPV_common_end(&v->s);
5287 av_freep(&v->mv_type_mb_plane);
5288 av_freep(&v->direct_mb_plane);
5289 av_freep(&v->forward_mb_plane);
5290 av_freep(&v->fieldtx_plane);
5291 av_freep(&v->acpred_plane);
5292 av_freep(&v->over_flags_plane);
5293 av_freep(&v->mb_type_base);
5294 av_freep(&v->blk_mv_type_base);
5295 av_freep(&v->mv_f_base);
5296 av_freep(&v->mv_f_last_base);
5297 av_freep(&v->mv_f_next_base);
5298 av_freep(&v->block);
5299 av_freep(&v->cbp_base);
5300 av_freep(&v->ttblk_base);
5301 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5302 av_freep(&v->luma_mv_base);
5303 ff_intrax8_common_end(&v->x8);
5308 /** Decode a VC1/WMV3 frame
5309 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5311 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5312 int *data_size, AVPacket *avpkt)
5314 const uint8_t *buf = avpkt->data;
5315 int buf_size = avpkt->size, n_slices = 0, i;
5316 VC1Context *v = avctx->priv_data;
5317 MpegEncContext *s = &v->s;
5318 AVFrame *pict = data;
5319 uint8_t *buf2 = NULL;
5320 const uint8_t *buf_start = buf;
5321 int mb_height, n_slices1=-1;
5326 } *slices = NULL, *tmp;
5328 if(s->flags & CODEC_FLAG_LOW_DELAY)
5331 /* no supplementary picture */
5332 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5333 /* special case for last picture */
5334 if (s->low_delay == 0 && s->next_picture_ptr) {
5335 *pict = s->next_picture_ptr->f;
5336 s->next_picture_ptr = NULL;
5338 *data_size = sizeof(AVFrame);
5344 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5345 if (v->profile < PROFILE_ADVANCED)
5346 avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
5348 avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
5351 //for advanced profile we may need to parse and unescape data
5352 if (avctx->codec_id == CODEC_ID_VC1 || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5354 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5356 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5357 const uint8_t *start, *end, *next;
5361 for (start = buf, end = buf + buf_size; next < end; start = next) {
5362 next = find_next_marker(start + 4, end);
5363 size = next - start - 4;
5364 if (size <= 0) continue;
5365 switch (AV_RB32(start)) {
5366 case VC1_CODE_FRAME:
5367 if (avctx->hwaccel ||
5368 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5370 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5372 case VC1_CODE_FIELD: {
5374 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5377 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5378 if (!slices[n_slices].buf)
5380 buf_size3 = vc1_unescape_buffer(start + 4, size,
5381 slices[n_slices].buf);
5382 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5384 /* assuming that the field marker is at the exact middle,
5385 hope it's correct */
5386 slices[n_slices].mby_start = s->mb_height >> 1;
5387 n_slices1 = n_slices - 1; // index of the last slice of the first field
5391 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5392 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5393 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5394 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5396 case VC1_CODE_SLICE: {
5398 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5401 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5402 if (!slices[n_slices].buf)
5404 buf_size3 = vc1_unescape_buffer(start + 4, size,
5405 slices[n_slices].buf);
5406 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5408 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5414 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5415 const uint8_t *divider;
5418 divider = find_next_marker(buf, buf + buf_size);
5419 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5420 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5422 } else { // found field marker, unescape second field
5423 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5427 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5428 if (!slices[n_slices].buf)
5430 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5431 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5433 slices[n_slices].mby_start = s->mb_height >> 1;
5434 n_slices1 = n_slices - 1;
5437 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5439 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5441 init_get_bits(&s->gb, buf2, buf_size2*8);
5443 init_get_bits(&s->gb, buf, buf_size*8);
5445 if (v->res_sprite) {
5446 v->new_sprite = !get_bits1(&s->gb);
5447 v->two_sprites = get_bits1(&s->gb);
5448 /* res_sprite means a Windows Media Image stream, CODEC_ID_*IMAGE means
5449 we're using the sprite compositor. These are intentionally kept separate
5450 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5451 the vc1 one for WVP2 */
5452 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5453 if (v->new_sprite) {
5454 // switch AVCodecContext parameters to those of the sprites
5455 avctx->width = avctx->coded_width = v->sprite_width;
5456 avctx->height = avctx->coded_height = v->sprite_height;
5463 if (s->context_initialized &&
5464 (s->width != avctx->coded_width ||
5465 s->height != avctx->coded_height)) {
5466 vc1_decode_end(avctx);
5469 if (!s->context_initialized) {
5470 if (ff_msmpeg4_decode_init(avctx) < 0 || vc1_decode_init_alloc_tables(v) < 0)
5473 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5475 if (v->profile == PROFILE_ADVANCED) {
5476 s->h_edge_pos = avctx->coded_width;
5477 s->v_edge_pos = avctx->coded_height;
5481 /* We need to set current_picture_ptr before reading the header,
5482 * otherwise we cannot store anything in there. */
5483 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5484 int i = ff_find_unused_picture(s, 0);
5487 s->current_picture_ptr = &s->picture[i];
5490 // do parse frame header
5491 v->pic_header_flag = 0;
5492 if (v->profile < PROFILE_ADVANCED) {
5493 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5497 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5502 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
5503 && s->pict_type != AV_PICTURE_TYPE_I) {
5504 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5508 // process pulldown flags
5509 s->current_picture_ptr->f.repeat_pict = 0;
5510 // Pulldown flags are only valid when 'broadcast' has been set.
5511 // So ticks_per_frame will be 2
5514 s->current_picture_ptr->f.repeat_pict = 1;
5515 } else if (v->rptfrm) {
5517 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5520 // for skipping the frame
5521 s->current_picture.f.pict_type = s->pict_type;
5522 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5524 /* skip B-frames if we don't have reference frames */
5525 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
5528 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5529 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5530 avctx->skip_frame >= AVDISCARD_ALL) {
5534 if (s->next_p_frame_damaged) {
5535 if (s->pict_type == AV_PICTURE_TYPE_B)
5538 s->next_p_frame_damaged = 0;
5541 if (ff_MPV_frame_start(s, avctx) < 0) {
5545 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5546 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5548 if ((CONFIG_VC1_VDPAU_DECODER)
5549 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5550 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5551 else if (avctx->hwaccel) {
5552 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
5554 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5556 if (avctx->hwaccel->end_frame(avctx) < 0)
5559 ff_er_frame_start(s);
5561 v->bits = buf_size * 8;
5562 if (v->field_mode) {
5564 s->current_picture.f.linesize[0] <<= 1;
5565 s->current_picture.f.linesize[1] <<= 1;
5566 s->current_picture.f.linesize[2] <<= 1;
5568 s->uvlinesize <<= 1;
5569 tmp[0] = v->mv_f_last[0];
5570 tmp[1] = v->mv_f_last[1];
5571 v->mv_f_last[0] = v->mv_f_next[0];
5572 v->mv_f_last[1] = v->mv_f_next[1];
5573 v->mv_f_next[0] = v->mv_f[0];
5574 v->mv_f_next[1] = v->mv_f[1];
5575 v->mv_f[0] = tmp[0];
5576 v->mv_f[1] = tmp[1];
5578 mb_height = s->mb_height >> v->field_mode;
5579 for (i = 0; i <= n_slices; i++) {
5580 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5581 if(v->field_mode <= 0) {
5582 av_log(v->s.avctx, AV_LOG_ERROR, "invalid end_mb_y %d\n", slices[i - 1].mby_start);
5585 v->second_field = 1;
5586 v->blocks_off = s->mb_width * s->mb_height << 1;
5587 v->mb_off = s->mb_stride * s->mb_height >> 1;
5589 v->second_field = 0;
5594 v->pic_header_flag = 0;
5595 if (v->field_mode && i == n_slices1 + 2) {
5596 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5597 av_log(v->s.avctx, AV_LOG_ERROR, "slice header damaged\n");
5600 } else if (get_bits1(&s->gb)) {
5601 v->pic_header_flag = 1;
5602 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5603 av_log(v->s.avctx, AV_LOG_ERROR, "slice header damaged\n");
5608 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5609 if (!v->field_mode || v->second_field)
5610 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5612 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5613 if (s->end_mb_y <= s->start_mb_y) {
5614 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
5617 vc1_decode_blocks(v);
5619 s->gb = slices[i].gb;
5621 if (v->field_mode) {
5622 v->second_field = 0;
5623 if (s->pict_type == AV_PICTURE_TYPE_B) {
5624 memcpy(v->mv_f_base, v->mv_f_next_base,
5625 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5627 s->current_picture.f.linesize[0] >>= 1;
5628 s->current_picture.f.linesize[1] >>= 1;
5629 s->current_picture.f.linesize[2] >>= 1;
5631 s->uvlinesize >>= 1;
5633 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
5634 // if (get_bits_count(&s->gb) > buf_size * 8)
5636 if(s->error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
5641 ff_MPV_frame_end(s);
5643 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5645 avctx->width = avctx->coded_width = v->output_width;
5646 avctx->height = avctx->coded_height = v->output_height;
5647 if (avctx->skip_frame >= AVDISCARD_NONREF)
5649 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5650 if (vc1_decode_sprites(v, &s->gb))
5653 *pict = v->sprite_output_frame;
5654 *data_size = sizeof(AVFrame);
5656 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5657 *pict = s->current_picture_ptr->f;
5658 } else if (s->last_picture_ptr != NULL) {
5659 *pict = s->last_picture_ptr->f;
5661 if (s->last_picture_ptr || s->low_delay) {
5662 *data_size = sizeof(AVFrame);
5663 ff_print_debug_info(s, pict);
5669 for (i = 0; i < n_slices; i++)
5670 av_free(slices[i].buf);
5676 for (i = 0; i < n_slices; i++)
5677 av_free(slices[i].buf);
5683 static const AVProfile profiles[] = {
5684 { FF_PROFILE_VC1_SIMPLE, "Simple" },
5685 { FF_PROFILE_VC1_MAIN, "Main" },
5686 { FF_PROFILE_VC1_COMPLEX, "Complex" },
5687 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5688 { FF_PROFILE_UNKNOWN },
5691 AVCodec ff_vc1_decoder = {
5693 .type = AVMEDIA_TYPE_VIDEO,
5695 .priv_data_size = sizeof(VC1Context),
5696 .init = vc1_decode_init,
5697 .close = vc1_decode_end,
5698 .decode = vc1_decode_frame,
5699 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5700 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5701 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5702 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5705 #if CONFIG_WMV3_DECODER
5706 AVCodec ff_wmv3_decoder = {
5708 .type = AVMEDIA_TYPE_VIDEO,
5709 .id = CODEC_ID_WMV3,
5710 .priv_data_size = sizeof(VC1Context),
5711 .init = vc1_decode_init,
5712 .close = vc1_decode_end,
5713 .decode = vc1_decode_frame,
5714 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5715 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5716 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5717 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5721 #if CONFIG_WMV3_VDPAU_DECODER
5722 AVCodec ff_wmv3_vdpau_decoder = {
5723 .name = "wmv3_vdpau",
5724 .type = AVMEDIA_TYPE_VIDEO,
5725 .id = CODEC_ID_WMV3,
5726 .priv_data_size = sizeof(VC1Context),
5727 .init = vc1_decode_init,
5728 .close = vc1_decode_end,
5729 .decode = vc1_decode_frame,
5730 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5731 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5732 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE },
5733 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5737 #if CONFIG_VC1_VDPAU_DECODER
5738 AVCodec ff_vc1_vdpau_decoder = {
5739 .name = "vc1_vdpau",
5740 .type = AVMEDIA_TYPE_VIDEO,
5742 .priv_data_size = sizeof(VC1Context),
5743 .init = vc1_decode_init,
5744 .close = vc1_decode_end,
5745 .decode = vc1_decode_frame,
5746 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5747 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5748 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_VDPAU_VC1, PIX_FMT_NONE },
5749 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5753 #if CONFIG_WMV3IMAGE_DECODER
5754 AVCodec ff_wmv3image_decoder = {
5755 .name = "wmv3image",
5756 .type = AVMEDIA_TYPE_VIDEO,
5757 .id = CODEC_ID_WMV3IMAGE,
5758 .priv_data_size = sizeof(VC1Context),
5759 .init = vc1_decode_init,
5760 .close = vc1_decode_end,
5761 .decode = vc1_decode_frame,
5762 .capabilities = CODEC_CAP_DR1,
5763 .flush = vc1_sprite_flush,
5764 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5765 .pix_fmts = ff_pixfmt_list_420
5769 #if CONFIG_VC1IMAGE_DECODER
5770 AVCodec ff_vc1image_decoder = {
5772 .type = AVMEDIA_TYPE_VIDEO,
5773 .id = CODEC_ID_VC1IMAGE,
5774 .priv_data_size = sizeof(VC1Context),
5775 .init = vc1_decode_init,
5776 .close = vc1_decode_end,
5777 .decode = vc1_decode_frame,
5778 .capabilities = CODEC_CAP_DR1,
5779 .flush = vc1_sprite_flush,
5780 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5781 .pix_fmts = ff_pixfmt_list_420