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
31 #include "error_resilience.h"
32 #include "mpegvideo.h"
34 #include "h264chroma.h"
37 #include "vc1acdata.h"
38 #include "msmpeg4data.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
63 static void init_block_index(VC1Context *v)
65 MpegEncContext *s = &v->s;
66 ff_init_block_index(s);
67 if (v->field_mode && !(v->second_field ^ v->tff)) {
68 s->dest[0] += s->current_picture_ptr->f.linesize[0];
69 s->dest[1] += s->current_picture_ptr->f.linesize[1];
70 s->dest[2] += s->current_picture_ptr->f.linesize[2];
74 /** @} */ //Bitplane group
76 static void vc1_put_signed_blocks_clamped(VC1Context *v)
78 MpegEncContext *s = &v->s;
79 int topleft_mb_pos, top_mb_pos;
80 int stride_y, fieldtx = 0;
83 /* The put pixels loop is always one MB row behind the decoding loop,
84 * because we can only put pixels when overlap filtering is done, and
85 * for filtering of the bottom edge of a MB, we need the next MB row
87 * Within the row, the put pixels loop is also one MB col behind the
88 * decoding loop. The reason for this is again, because for filtering
89 * of the right MB edge, we need the next MB present. */
90 if (!s->first_slice_line) {
92 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
93 if (v->fcm == ILACE_FRAME)
94 fieldtx = v->fieldtx_plane[topleft_mb_pos];
95 stride_y = s->linesize << fieldtx;
96 v_dist = (16 - fieldtx) >> (fieldtx == 0);
97 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
98 s->dest[0] - 16 * s->linesize - 16,
100 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
101 s->dest[0] - 16 * s->linesize - 8,
103 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
104 s->dest[0] - v_dist * s->linesize - 16,
106 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
107 s->dest[0] - v_dist * s->linesize - 8,
109 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
110 s->dest[1] - 8 * s->uvlinesize - 8,
112 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
113 s->dest[2] - 8 * s->uvlinesize - 8,
116 if (s->mb_x == s->mb_width - 1) {
117 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
118 if (v->fcm == ILACE_FRAME)
119 fieldtx = v->fieldtx_plane[top_mb_pos];
120 stride_y = s->linesize << fieldtx;
121 v_dist = fieldtx ? 15 : 8;
122 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
123 s->dest[0] - 16 * s->linesize,
125 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
126 s->dest[0] - 16 * s->linesize + 8,
128 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
129 s->dest[0] - v_dist * s->linesize,
131 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
132 s->dest[0] - v_dist * s->linesize + 8,
134 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
135 s->dest[1] - 8 * s->uvlinesize,
137 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
138 s->dest[2] - 8 * s->uvlinesize,
143 #define inc_blk_idx(idx) do { \
145 if (idx >= v->n_allocated_blks) \
149 inc_blk_idx(v->topleft_blk_idx);
150 inc_blk_idx(v->top_blk_idx);
151 inc_blk_idx(v->left_blk_idx);
152 inc_blk_idx(v->cur_blk_idx);
155 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
157 MpegEncContext *s = &v->s;
159 if (!s->first_slice_line) {
160 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
162 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
163 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
164 for (j = 0; j < 2; j++) {
165 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
167 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
170 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
172 if (s->mb_y == s->end_mb_y - 1) {
174 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
175 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
176 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
178 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
182 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
184 MpegEncContext *s = &v->s;
187 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
188 * means it runs two rows/cols behind the decoding loop. */
189 if (!s->first_slice_line) {
191 if (s->mb_y >= s->start_mb_y + 2) {
192 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
195 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
196 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
197 for (j = 0; j < 2; j++) {
198 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
200 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
204 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
207 if (s->mb_x == s->mb_width - 1) {
208 if (s->mb_y >= s->start_mb_y + 2) {
209 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
212 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
213 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
214 for (j = 0; j < 2; j++) {
215 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
217 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
221 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
224 if (s->mb_y == s->end_mb_y) {
227 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
228 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
230 for (j = 0; j < 2; j++) {
231 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
236 if (s->mb_x == s->mb_width - 1) {
238 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
239 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
241 for (j = 0; j < 2; j++) {
242 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
250 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
252 MpegEncContext *s = &v->s;
255 if (v->condover == CONDOVER_NONE)
258 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
260 /* Within a MB, the horizontal overlap always runs before the vertical.
261 * To accomplish that, we run the H on left and internal borders of the
262 * currently decoded MB. Then, we wait for the next overlap iteration
263 * to do H overlap on the right edge of this MB, before moving over and
264 * running the V overlap. Therefore, the V overlap makes us trail by one
265 * MB col and the H overlap filter makes us trail by one MB row. This
266 * is reflected in the time at which we run the put_pixels loop. */
267 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
268 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
269 v->over_flags_plane[mb_pos - 1])) {
270 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
271 v->block[v->cur_blk_idx][0]);
272 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
273 v->block[v->cur_blk_idx][2]);
274 if (!(s->flags & CODEC_FLAG_GRAY)) {
275 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
276 v->block[v->cur_blk_idx][4]);
277 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
278 v->block[v->cur_blk_idx][5]);
281 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
282 v->block[v->cur_blk_idx][1]);
283 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
284 v->block[v->cur_blk_idx][3]);
286 if (s->mb_x == s->mb_width - 1) {
287 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
288 v->over_flags_plane[mb_pos - s->mb_stride])) {
289 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
290 v->block[v->cur_blk_idx][0]);
291 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
292 v->block[v->cur_blk_idx][1]);
293 if (!(s->flags & CODEC_FLAG_GRAY)) {
294 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
295 v->block[v->cur_blk_idx][4]);
296 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
297 v->block[v->cur_blk_idx][5]);
300 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
301 v->block[v->cur_blk_idx][2]);
302 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
303 v->block[v->cur_blk_idx][3]);
306 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
307 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
308 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
309 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
310 v->block[v->left_blk_idx][0]);
311 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
312 v->block[v->left_blk_idx][1]);
313 if (!(s->flags & CODEC_FLAG_GRAY)) {
314 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
315 v->block[v->left_blk_idx][4]);
316 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
317 v->block[v->left_blk_idx][5]);
320 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
321 v->block[v->left_blk_idx][2]);
322 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
323 v->block[v->left_blk_idx][3]);
327 /** Do motion compensation over 1 macroblock
328 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
330 static void vc1_mc_1mv(VC1Context *v, int dir)
332 MpegEncContext *s = &v->s;
333 H264ChromaContext *h264chroma = &v->h264chroma;
334 uint8_t *srcY, *srcU, *srcV;
335 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
336 int v_edge_pos = s->v_edge_pos >> v->field_mode;
338 uint8_t (*luty)[256], (*lutuv)[256];
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 for (i = 0; i < 4; i++) {
352 s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = mx;
353 s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = my;
357 uvmx = (mx + ((mx & 3) == 3)) >> 1;
358 uvmy = (my + ((my & 3) == 3)) >> 1;
359 v->luma_mv[s->mb_x][0] = uvmx;
360 v->luma_mv[s->mb_x][1] = uvmy;
363 v->cur_field_type != v->ref_field_type[dir]) {
364 my = my - 2 + 4 * v->cur_field_type;
365 uvmy = uvmy - 2 + 4 * v->cur_field_type;
368 // fastuvmc shall be ignored for interlaced frame picture
369 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
370 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
371 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
374 if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
375 srcY = s->current_picture.f.data[0];
376 srcU = s->current_picture.f.data[1];
377 srcV = s->current_picture.f.data[2];
379 lutuv = v->curr_lutuv;
380 use_ic = *v->curr_use_ic;
382 srcY = s->last_picture.f.data[0];
383 srcU = s->last_picture.f.data[1];
384 srcV = s->last_picture.f.data[2];
386 lutuv = v->last_lutuv;
387 use_ic = v->last_use_ic;
390 srcY = s->next_picture.f.data[0];
391 srcU = s->next_picture.f.data[1];
392 srcV = s->next_picture.f.data[2];
394 lutuv = v->next_lutuv;
395 use_ic = v->next_use_ic;
398 if (!srcY || !srcU) {
399 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
403 src_x = s->mb_x * 16 + (mx >> 2);
404 src_y = s->mb_y * 16 + (my >> 2);
405 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
406 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
408 if (v->profile != PROFILE_ADVANCED) {
409 src_x = av_clip( src_x, -16, s->mb_width * 16);
410 src_y = av_clip( src_y, -16, s->mb_height * 16);
411 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
412 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
414 src_x = av_clip( src_x, -17, s->avctx->coded_width);
415 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
416 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
417 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
420 srcY += src_y * s->linesize + src_x;
421 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
422 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
424 if (v->field_mode && v->ref_field_type[dir]) {
425 srcY += s->current_picture_ptr->f.linesize[0];
426 srcU += s->current_picture_ptr->f.linesize[1];
427 srcV += s->current_picture_ptr->f.linesize[2];
430 /* for grayscale we should not try to read from unknown area */
431 if (s->flags & CODEC_FLAG_GRAY) {
432 srcU = s->edge_emu_buffer + 18 * s->linesize;
433 srcV = s->edge_emu_buffer + 18 * s->linesize;
436 if (v->rangeredfrm || use_ic
437 || s->h_edge_pos < 22 || v_edge_pos < 22
438 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
439 || (unsigned)(src_y - 1) > v_edge_pos - (my&3) - 16 - 3) {
440 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
442 srcY -= s->mspel * (1 + s->linesize);
443 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
444 s->linesize, s->linesize,
445 17 + s->mspel * 2, 17 + s->mspel * 2,
446 src_x - s->mspel, src_y - s->mspel,
447 s->h_edge_pos, v_edge_pos);
448 srcY = s->edge_emu_buffer;
449 s->vdsp.emulated_edge_mc(uvbuf, srcU,
450 s->uvlinesize, s->uvlinesize,
453 s->h_edge_pos >> 1, v_edge_pos >> 1);
454 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV,
455 s->uvlinesize, s->uvlinesize,
458 s->h_edge_pos >> 1, v_edge_pos >> 1);
461 /* if we deal with range reduction we need to scale source blocks */
462 if (v->rangeredfrm) {
467 for (j = 0; j < 17 + s->mspel * 2; j++) {
468 for (i = 0; i < 17 + s->mspel * 2; i++)
469 src[i] = ((src[i] - 128) >> 1) + 128;
474 for (j = 0; j < 9; j++) {
475 for (i = 0; i < 9; i++) {
476 src[i] = ((src[i] - 128) >> 1) + 128;
477 src2[i] = ((src2[i] - 128) >> 1) + 128;
479 src += s->uvlinesize;
480 src2 += s->uvlinesize;
483 /* if we deal with intensity compensation we need to scale source blocks */
489 for (j = 0; j < 17 + s->mspel * 2; j++) {
490 int f = v->field_mode ? v->ref_field_type[dir] : ((j + src_y - s->mspel) & 1) ;
491 for (i = 0; i < 17 + s->mspel * 2; i++)
492 src[i] = luty[f][src[i]];
497 for (j = 0; j < 9; j++) {
498 int f = v->field_mode ? v->ref_field_type[dir] : ((j + uvsrc_y) & 1);
499 for (i = 0; i < 9; i++) {
500 src[i] = lutuv[f][src[i]];
501 src2[i] = lutuv[f][src2[i]];
503 src += s->uvlinesize;
504 src2 += s->uvlinesize;
507 srcY += s->mspel * (1 + s->linesize);
511 dxy = ((my & 3) << 2) | (mx & 3);
512 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
513 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
514 srcY += s->linesize * 8;
515 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
516 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
517 } else { // hpel mc - always used for luma
518 dxy = (my & 2) | ((mx & 2) >> 1);
520 s->hdsp.put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
522 s->hdsp.put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
525 if (s->flags & CODEC_FLAG_GRAY) return;
526 /* Chroma MC always uses qpel bilinear */
527 uvmx = (uvmx & 3) << 1;
528 uvmy = (uvmy & 3) << 1;
530 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
531 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
533 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
534 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
538 static inline int median4(int a, int b, int c, int d)
541 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
542 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
544 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
545 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
549 /** Do motion compensation for 4-MV macroblock - luminance block
551 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
553 MpegEncContext *s = &v->s;
555 int dxy, mx, my, src_x, src_y;
557 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
558 int v_edge_pos = s->v_edge_pos >> v->field_mode;
559 uint8_t (*luty)[256];
562 if ((!v->field_mode ||
563 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
564 !v->s.last_picture.f.data[0])
567 mx = s->mv[dir][n][0];
568 my = s->mv[dir][n][1];
571 if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
572 srcY = s->current_picture.f.data[0];
574 use_ic = *v->curr_use_ic;
576 srcY = s->last_picture.f.data[0];
578 use_ic = v->last_use_ic;
581 srcY = s->next_picture.f.data[0];
583 use_ic = v->next_use_ic;
587 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
592 if (v->cur_field_type != v->ref_field_type[dir])
593 my = my - 2 + 4 * v->cur_field_type;
596 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
597 int same_count = 0, opp_count = 0, k;
598 int chosen_mv[2][4][2], f;
600 for (k = 0; k < 4; k++) {
601 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
602 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
603 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
607 f = opp_count > same_count;
608 switch (f ? opp_count : same_count) {
610 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
611 chosen_mv[f][2][0], chosen_mv[f][3][0]);
612 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
613 chosen_mv[f][2][1], chosen_mv[f][3][1]);
616 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
617 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
620 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
621 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
626 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
627 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
628 for (k = 0; k < 4; k++)
629 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
632 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
634 int width = s->avctx->coded_width;
635 int height = s->avctx->coded_height >> 1;
636 if (s->pict_type == AV_PICTURE_TYPE_P) {
637 s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][0] = mx;
638 s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][1] = my;
640 qx = (s->mb_x * 16) + (mx >> 2);
641 qy = (s->mb_y * 8) + (my >> 3);
646 mx -= 4 * (qx - width);
649 else if (qy > height + 1)
650 my -= 8 * (qy - height - 1);
653 if ((v->fcm == ILACE_FRAME) && fieldmv)
654 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
656 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
658 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
660 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
662 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
664 if (v->profile != PROFILE_ADVANCED) {
665 src_x = av_clip(src_x, -16, s->mb_width * 16);
666 src_y = av_clip(src_y, -16, s->mb_height * 16);
668 src_x = av_clip(src_x, -17, s->avctx->coded_width);
669 if (v->fcm == ILACE_FRAME) {
671 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
673 src_y = av_clip(src_y, -18, s->avctx->coded_height);
675 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
679 srcY += src_y * s->linesize + src_x;
680 if (v->field_mode && v->ref_field_type[dir])
681 srcY += s->current_picture_ptr->f.linesize[0];
683 if (fieldmv && !(src_y & 1))
685 if (fieldmv && (src_y & 1) && src_y < 4)
687 if (v->rangeredfrm || use_ic
688 || s->h_edge_pos < 13 || v_edge_pos < 23
689 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
690 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
691 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
692 /* check emulate edge stride and offset */
693 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
694 s->linesize, s->linesize,
695 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
696 src_x - s->mspel, src_y - (s->mspel << fieldmv),
697 s->h_edge_pos, v_edge_pos);
698 srcY = s->edge_emu_buffer;
699 /* if we deal with range reduction we need to scale source blocks */
700 if (v->rangeredfrm) {
705 for (j = 0; j < 9 + s->mspel * 2; j++) {
706 for (i = 0; i < 9 + s->mspel * 2; i++)
707 src[i] = ((src[i] - 128) >> 1) + 128;
708 src += s->linesize << fieldmv;
711 /* if we deal with intensity compensation we need to scale source blocks */
717 for (j = 0; j < 9 + s->mspel * 2; j++) {
718 int f = v->field_mode ? v->ref_field_type[dir] : (((j<<fieldmv)+src_y - (s->mspel << fieldmv)) & 1);
719 for (i = 0; i < 9 + s->mspel * 2; i++)
720 src[i] = luty[f][src[i]];
721 src += s->linesize << fieldmv;
724 srcY += s->mspel * (1 + (s->linesize << fieldmv));
728 dxy = ((my & 3) << 2) | (mx & 3);
730 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
732 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
733 } else { // hpel mc - always used for luma
734 dxy = (my & 2) | ((mx & 2) >> 1);
736 s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
738 s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
742 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
745 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
747 idx = ((a[3] != flag) << 3)
748 | ((a[2] != flag) << 2)
749 | ((a[1] != flag) << 1)
752 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
753 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
755 } else if (count[idx] == 1) {
758 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
759 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
762 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
763 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
766 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
767 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
770 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
771 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
774 } else if (count[idx] == 2) {
776 for (i = 0; i < 3; i++)
781 for (i = t1 + 1; i < 4; i++)
786 *tx = (mvx[t1] + mvx[t2]) / 2;
787 *ty = (mvy[t1] + mvy[t2]) / 2;
795 /** Do motion compensation for 4-MV macroblock - both chroma blocks
797 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
799 MpegEncContext *s = &v->s;
800 H264ChromaContext *h264chroma = &v->h264chroma;
801 uint8_t *srcU, *srcV;
802 int uvmx, uvmy, uvsrc_x, uvsrc_y;
803 int k, tx = 0, ty = 0;
804 int mvx[4], mvy[4], intra[4], mv_f[4];
806 int chroma_ref_type = v->cur_field_type;
807 int v_edge_pos = s->v_edge_pos >> v->field_mode;
808 uint8_t (*lutuv)[256];
811 if (!v->field_mode && !v->s.last_picture.f.data[0])
813 if (s->flags & CODEC_FLAG_GRAY)
816 for (k = 0; k < 4; k++) {
817 mvx[k] = s->mv[dir][k][0];
818 mvy[k] = s->mv[dir][k][1];
819 intra[k] = v->mb_type[0][s->block_index[k]];
821 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
824 /* calculate chroma MV vector from four luma MVs */
825 if (!v->field_mode || (v->field_mode && !v->numref)) {
826 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
827 chroma_ref_type = v->reffield;
829 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
830 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
831 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
832 return; //no need to do MC for intra blocks
836 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
838 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
840 chroma_ref_type = !v->cur_field_type;
842 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
844 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
845 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
846 uvmx = (tx + ((tx & 3) == 3)) >> 1;
847 uvmy = (ty + ((ty & 3) == 3)) >> 1;
849 v->luma_mv[s->mb_x][0] = uvmx;
850 v->luma_mv[s->mb_x][1] = uvmy;
853 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
854 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
856 // Field conversion bias
857 if (v->cur_field_type != chroma_ref_type)
858 uvmy += 2 - 4 * chroma_ref_type;
860 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
861 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
863 if (v->profile != PROFILE_ADVANCED) {
864 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
865 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
867 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
868 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
872 if (v->field_mode && (v->cur_field_type != chroma_ref_type) && v->second_field) {
873 srcU = s->current_picture.f.data[1];
874 srcV = s->current_picture.f.data[2];
875 lutuv = v->curr_lutuv;
876 use_ic = *v->curr_use_ic;
878 srcU = s->last_picture.f.data[1];
879 srcV = s->last_picture.f.data[2];
880 lutuv = v->last_lutuv;
881 use_ic = v->last_use_ic;
884 srcU = s->next_picture.f.data[1];
885 srcV = s->next_picture.f.data[2];
886 lutuv = v->next_lutuv;
887 use_ic = v->next_use_ic;
891 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
895 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
896 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
899 if (chroma_ref_type) {
900 srcU += s->current_picture_ptr->f.linesize[1];
901 srcV += s->current_picture_ptr->f.linesize[2];
905 if (v->rangeredfrm || use_ic
906 || s->h_edge_pos < 18 || v_edge_pos < 18
907 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
908 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
909 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU,
910 s->uvlinesize, s->uvlinesize,
911 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
912 s->h_edge_pos >> 1, v_edge_pos >> 1);
913 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV,
914 s->uvlinesize, s->uvlinesize,
915 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
916 s->h_edge_pos >> 1, v_edge_pos >> 1);
917 srcU = s->edge_emu_buffer;
918 srcV = s->edge_emu_buffer + 16;
920 /* if we deal with range reduction we need to scale source blocks */
921 if (v->rangeredfrm) {
927 for (j = 0; j < 9; j++) {
928 for (i = 0; i < 9; i++) {
929 src[i] = ((src[i] - 128) >> 1) + 128;
930 src2[i] = ((src2[i] - 128) >> 1) + 128;
932 src += s->uvlinesize;
933 src2 += s->uvlinesize;
936 /* if we deal with intensity compensation we need to scale source blocks */
943 for (j = 0; j < 9; j++) {
944 int f = v->field_mode ? chroma_ref_type : ((j + uvsrc_y) & 1);
945 for (i = 0; i < 9; i++) {
946 src[i] = lutuv[f][src[i]];
947 src2[i] = lutuv[f][src2[i]];
949 src += s->uvlinesize;
950 src2 += s->uvlinesize;
955 /* Chroma MC always uses qpel bilinear */
956 uvmx = (uvmx & 3) << 1;
957 uvmy = (uvmy & 3) << 1;
959 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
960 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
962 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
963 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
967 /** Do motion compensation for 4-MV interlaced frame chroma macroblock (both U and V)
969 static void vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)
971 MpegEncContext *s = &v->s;
972 H264ChromaContext *h264chroma = &v->h264chroma;
973 uint8_t *srcU, *srcV;
974 int uvsrc_x, uvsrc_y;
975 int uvmx_field[4], uvmy_field[4];
977 int fieldmv = v->blk_mv_type[s->block_index[0]];
978 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
979 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
980 int v_edge_pos = s->v_edge_pos >> 1;
982 uint8_t (*lutuv)[256];
984 if (s->flags & CODEC_FLAG_GRAY)
987 for (i = 0; i < 4; i++) {
988 int d = i < 2 ? dir: dir2;
990 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
993 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
995 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
998 for (i = 0; i < 4; i++) {
999 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
1000 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
1001 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
1002 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
1003 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1004 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1005 if (i < 2 ? dir : dir2) {
1006 srcU = s->next_picture.f.data[1];
1007 srcV = s->next_picture.f.data[2];
1008 lutuv = v->next_lutuv;
1009 use_ic = v->next_use_ic;
1011 srcU = s->last_picture.f.data[1];
1012 srcV = s->last_picture.f.data[2];
1013 lutuv = v->last_lutuv;
1014 use_ic = v->last_use_ic;
1018 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1019 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1020 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
1021 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
1023 if (fieldmv && !(uvsrc_y & 1))
1024 v_edge_pos = (s->v_edge_pos >> 1) - 1;
1026 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
1029 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
1030 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
1031 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
1032 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU,
1033 s->uvlinesize, s->uvlinesize,
1034 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1035 s->h_edge_pos >> 1, v_edge_pos);
1036 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV,
1037 s->uvlinesize, s->uvlinesize,
1038 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1039 s->h_edge_pos >> 1, v_edge_pos);
1040 srcU = s->edge_emu_buffer;
1041 srcV = s->edge_emu_buffer + 16;
1043 /* if we deal with intensity compensation we need to scale source blocks */
1046 uint8_t *src, *src2;
1050 for (j = 0; j < 5; j++) {
1051 int f = (uvsrc_y + (j << fieldmv)) & 1;
1052 for (i = 0; i < 5; i++) {
1053 src[i] = lutuv[f][src[i]];
1054 src2[i] = lutuv[f][src2[i]];
1056 src += s->uvlinesize << fieldmv;
1057 src2 += s->uvlinesize << fieldmv;
1063 h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1064 h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1066 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1067 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1071 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1072 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1074 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]);
1075 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]);
1081 /***********************************************************************/
1083 * @name VC-1 Block-level functions
1084 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1090 * @brief Get macroblock-level quantizer scale
1092 #define GET_MQUANT() \
1093 if (v->dquantfrm) { \
1095 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1096 if (v->dqbilevel) { \
1097 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1099 mqdiff = get_bits(gb, 3); \
1101 mquant = v->pq + mqdiff; \
1103 mquant = get_bits(gb, 5); \
1106 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1107 edges = 1 << v->dqsbedge; \
1108 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1109 edges = (3 << v->dqsbedge) % 15; \
1110 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1112 if ((edges&1) && !s->mb_x) \
1113 mquant = v->altpq; \
1114 if ((edges&2) && s->first_slice_line) \
1115 mquant = v->altpq; \
1116 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1117 mquant = v->altpq; \
1118 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1119 mquant = v->altpq; \
1120 if (!mquant || mquant > 31) { \
1121 av_log(v->s.avctx, AV_LOG_ERROR, \
1122 "Overriding invalid mquant %d\n", mquant); \
1128 * @def GET_MVDATA(_dmv_x, _dmv_y)
1129 * @brief Get MV differentials
1130 * @see MVDATA decoding from 8.3.5.2, p(1)20
1131 * @param _dmv_x Horizontal differential for decoded MV
1132 * @param _dmv_y Vertical differential for decoded MV
1134 #define GET_MVDATA(_dmv_x, _dmv_y) \
1135 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1136 VC1_MV_DIFF_VLC_BITS, 2); \
1138 mb_has_coeffs = 1; \
1141 mb_has_coeffs = 0; \
1144 _dmv_x = _dmv_y = 0; \
1145 } else if (index == 35) { \
1146 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1147 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1148 } else if (index == 36) { \
1153 index1 = index % 6; \
1154 if (!s->quarter_sample && index1 == 5) val = 1; \
1156 if (size_table[index1] - val > 0) \
1157 val = get_bits(gb, size_table[index1] - val); \
1159 sign = 0 - (val&1); \
1160 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1162 index1 = index / 6; \
1163 if (!s->quarter_sample && index1 == 5) val = 1; \
1165 if (size_table[index1] - val > 0) \
1166 val = get_bits(gb, size_table[index1] - val); \
1168 sign = 0 - (val & 1); \
1169 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1172 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1173 int *dmv_y, int *pred_flag)
1176 int extend_x = 0, extend_y = 0;
1177 GetBitContext *gb = &v->s.gb;
1180 const int* offs_tab;
1183 bits = VC1_2REF_MVDATA_VLC_BITS;
1186 bits = VC1_1REF_MVDATA_VLC_BITS;
1189 switch (v->dmvrange) {
1197 extend_x = extend_y = 1;
1200 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1202 *dmv_x = get_bits(gb, v->k_x);
1203 *dmv_y = get_bits(gb, v->k_y);
1206 *pred_flag = *dmv_y & 1;
1207 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1209 *dmv_y = (*dmv_y + (*dmv_y & 1)) >> 1;
1214 av_assert0(index < esc);
1216 offs_tab = offset_table2;
1218 offs_tab = offset_table1;
1219 index1 = (index + 1) % 9;
1221 val = get_bits(gb, index1 + extend_x);
1222 sign = 0 -(val & 1);
1223 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1227 offs_tab = offset_table2;
1229 offs_tab = offset_table1;
1230 index1 = (index + 1) / 9;
1231 if (index1 > v->numref) {
1232 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1233 sign = 0 - (val & 1);
1234 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1237 if (v->numref && pred_flag)
1238 *pred_flag = index1 & 1;
1242 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1244 int scaledvalue, refdist;
1245 int scalesame1, scalesame2;
1246 int scalezone1_x, zone1offset_x;
1247 int table_index = dir ^ v->second_field;
1249 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1250 refdist = v->refdist;
1252 refdist = dir ? v->brfd : v->frfd;
1255 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1256 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1257 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1258 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1263 if (FFABS(n) < scalezone1_x)
1264 scaledvalue = (n * scalesame1) >> 8;
1267 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1269 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1272 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1275 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1277 int scaledvalue, refdist;
1278 int scalesame1, scalesame2;
1279 int scalezone1_y, zone1offset_y;
1280 int table_index = dir ^ v->second_field;
1282 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1283 refdist = v->refdist;
1285 refdist = dir ? v->brfd : v->frfd;
1288 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1289 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1290 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1291 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1296 if (FFABS(n) < scalezone1_y)
1297 scaledvalue = (n * scalesame1) >> 8;
1300 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1302 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1306 if (v->cur_field_type && !v->ref_field_type[dir])
1307 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1309 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1312 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1314 int scalezone1_x, zone1offset_x;
1315 int scaleopp1, scaleopp2, brfd;
1318 brfd = FFMIN(v->brfd, 3);
1319 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1320 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1321 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1322 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1327 if (FFABS(n) < scalezone1_x)
1328 scaledvalue = (n * scaleopp1) >> 8;
1331 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1333 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1336 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1339 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1341 int scalezone1_y, zone1offset_y;
1342 int scaleopp1, scaleopp2, brfd;
1345 brfd = FFMIN(v->brfd, 3);
1346 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1347 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1348 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1349 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1354 if (FFABS(n) < scalezone1_y)
1355 scaledvalue = (n * scaleopp1) >> 8;
1358 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1360 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1363 if (v->cur_field_type && !v->ref_field_type[dir]) {
1364 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1366 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1370 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1373 int brfd, scalesame;
1374 int hpel = 1 - v->s.quarter_sample;
1377 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1379 n = scaleforsame_y(v, i, n, dir) << hpel;
1381 n = scaleforsame_x(v, n, dir) << hpel;
1384 brfd = FFMIN(v->brfd, 3);
1385 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1387 n = (n * scalesame >> 8) << hpel;
1391 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1394 int refdist, scaleopp;
1395 int hpel = 1 - v->s.quarter_sample;
1398 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1400 n = scaleforopp_y(v, n, dir) << hpel;
1402 n = scaleforopp_x(v, n) << hpel;
1405 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1406 refdist = FFMIN(v->refdist, 3);
1408 refdist = dir ? v->brfd : v->frfd;
1409 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1411 n = (n * scaleopp >> 8) << hpel;
1415 /** Predict and set motion vector
1417 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1418 int mv1, int r_x, int r_y, uint8_t* is_intra,
1419 int pred_flag, int dir)
1421 MpegEncContext *s = &v->s;
1422 int xy, wrap, off = 0;
1426 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1427 int opposite, a_f, b_f, c_f;
1428 int16_t field_predA[2];
1429 int16_t field_predB[2];
1430 int16_t field_predC[2];
1431 int a_valid, b_valid, c_valid;
1432 int hybridmv_thresh, y_bias = 0;
1434 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1435 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1439 /* scale MV difference to be quad-pel */
1440 dmv_x <<= 1 - s->quarter_sample;
1441 dmv_y <<= 1 - s->quarter_sample;
1443 wrap = s->b8_stride;
1444 xy = s->block_index[n];
1447 s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
1448 s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
1449 s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
1450 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
1451 if (mv1) { /* duplicate motion data for 1-MV block */
1452 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1453 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1454 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1455 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1456 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1457 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1458 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1459 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1460 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1461 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1462 s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1463 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1464 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1469 C = s->current_picture.motion_val[dir][xy - 1 + v->blocks_off];
1470 A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
1472 if (v->field_mode && mixedmv_pic)
1473 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1475 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1477 //in 4-MV mode different blocks have different B predictor position
1480 off = (s->mb_x > 0) ? -1 : 1;
1483 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1492 B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
1494 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1495 b_valid = a_valid && (s->mb_width > 1);
1496 c_valid = s->mb_x || (n == 1 || n == 3);
1497 if (v->field_mode) {
1498 a_valid = a_valid && !is_intra[xy - wrap];
1499 b_valid = b_valid && !is_intra[xy - wrap + off];
1500 c_valid = c_valid && !is_intra[xy - 1];
1504 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1505 num_oppfield += a_f;
1506 num_samefield += 1 - a_f;
1507 field_predA[0] = A[0];
1508 field_predA[1] = A[1];
1510 field_predA[0] = field_predA[1] = 0;
1514 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1515 num_oppfield += b_f;
1516 num_samefield += 1 - b_f;
1517 field_predB[0] = B[0];
1518 field_predB[1] = B[1];
1520 field_predB[0] = field_predB[1] = 0;
1524 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1525 num_oppfield += c_f;
1526 num_samefield += 1 - c_f;
1527 field_predC[0] = C[0];
1528 field_predC[1] = C[1];
1530 field_predC[0] = field_predC[1] = 0;
1534 if (v->field_mode) {
1536 // REFFIELD determines if the last field or the second-last field is
1537 // to be used as reference
1538 opposite = 1 - v->reffield;
1540 if (num_samefield <= num_oppfield)
1541 opposite = 1 - pred_flag;
1543 opposite = pred_flag;
1548 if (a_valid && !a_f) {
1549 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1550 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1552 if (b_valid && !b_f) {
1553 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1554 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1556 if (c_valid && !c_f) {
1557 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1558 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1560 v->mv_f[dir][xy + v->blocks_off] = 1;
1561 v->ref_field_type[dir] = !v->cur_field_type;
1563 if (a_valid && a_f) {
1564 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1565 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1567 if (b_valid && b_f) {
1568 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1569 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1571 if (c_valid && c_f) {
1572 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1573 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1575 v->mv_f[dir][xy + v->blocks_off] = 0;
1576 v->ref_field_type[dir] = v->cur_field_type;
1580 px = field_predA[0];
1581 py = field_predA[1];
1582 } else if (c_valid) {
1583 px = field_predC[0];
1584 py = field_predC[1];
1585 } else if (b_valid) {
1586 px = field_predB[0];
1587 py = field_predB[1];
1593 if (num_samefield + num_oppfield > 1) {
1594 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1595 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1598 /* Pullback MV as specified in 8.3.5.3.4 */
1599 if (!v->field_mode) {
1601 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1602 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1603 X = (s->mb_width << 6) - 4;
1604 Y = (s->mb_height << 6) - 4;
1606 if (qx + px < -60) px = -60 - qx;
1607 if (qy + py < -60) py = -60 - qy;
1609 if (qx + px < -28) px = -28 - qx;
1610 if (qy + py < -28) py = -28 - qy;
1612 if (qx + px > X) px = X - qx;
1613 if (qy + py > Y) py = Y - qy;
1616 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1617 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1618 hybridmv_thresh = 32;
1619 if (a_valid && c_valid) {
1620 if (is_intra[xy - wrap])
1621 sum = FFABS(px) + FFABS(py);
1623 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1624 if (sum > hybridmv_thresh) {
1625 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1626 px = field_predA[0];
1627 py = field_predA[1];
1629 px = field_predC[0];
1630 py = field_predC[1];
1633 if (is_intra[xy - 1])
1634 sum = FFABS(px) + FFABS(py);
1636 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1637 if (sum > hybridmv_thresh) {
1638 if (get_bits1(&s->gb)) {
1639 px = field_predA[0];
1640 py = field_predA[1];
1642 px = field_predC[0];
1643 py = field_predC[1];
1650 if (v->field_mode && v->numref)
1652 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1654 /* store MV using signed modulus of MV range defined in 4.11 */
1655 s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1656 s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
1657 if (mv1) { /* duplicate motion data for 1-MV block */
1658 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1659 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1660 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1661 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1662 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1663 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1664 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1665 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];
1669 /** Predict and set motion vector for interlaced frame picture MBs
1671 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1672 int mvn, int r_x, int r_y, uint8_t* is_intra, int dir)
1674 MpegEncContext *s = &v->s;
1675 int xy, wrap, off = 0;
1676 int A[2], B[2], C[2];
1678 int a_valid = 0, b_valid = 0, c_valid = 0;
1679 int field_a, field_b, field_c; // 0: same, 1: opposit
1680 int total_valid, num_samefield, num_oppfield;
1681 int pos_c, pos_b, n_adj;
1683 wrap = s->b8_stride;
1684 xy = s->block_index[n];
1687 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1688 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1689 s->current_picture.motion_val[1][xy][0] = 0;
1690 s->current_picture.motion_val[1][xy][1] = 0;
1691 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1692 s->current_picture.motion_val[0][xy + 1][0] = 0;
1693 s->current_picture.motion_val[0][xy + 1][1] = 0;
1694 s->current_picture.motion_val[0][xy + wrap][0] = 0;
1695 s->current_picture.motion_val[0][xy + wrap][1] = 0;
1696 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1697 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1698 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1699 s->current_picture.motion_val[1][xy + 1][0] = 0;
1700 s->current_picture.motion_val[1][xy + 1][1] = 0;
1701 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1702 s->current_picture.motion_val[1][xy + wrap][1] = 0;
1703 s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
1704 s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
1709 off = ((n == 0) || (n == 1)) ? 1 : -1;
1711 if (s->mb_x || (n == 1) || (n == 3)) {
1712 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1713 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1714 A[0] = s->current_picture.motion_val[dir][xy - 1][0];
1715 A[1] = s->current_picture.motion_val[dir][xy - 1][1];
1717 } else { // current block has frame mv and cand. has field MV (so average)
1718 A[0] = (s->current_picture.motion_val[dir][xy - 1][0]
1719 + s->current_picture.motion_val[dir][xy - 1 + off * wrap][0] + 1) >> 1;
1720 A[1] = (s->current_picture.motion_val[dir][xy - 1][1]
1721 + s->current_picture.motion_val[dir][xy - 1 + off * wrap][1] + 1) >> 1;
1724 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1730 /* Predict B and C */
1731 B[0] = B[1] = C[0] = C[1] = 0;
1732 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1733 if (!s->first_slice_line) {
1734 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1737 pos_b = s->block_index[n_adj] - 2 * wrap;
1738 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1739 n_adj = (n & 2) | (n & 1);
1741 B[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][0];
1742 B[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][1];
1743 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1744 B[0] = (B[0] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1745 B[1] = (B[1] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1748 if (s->mb_width > 1) {
1749 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1752 pos_c = s->block_index[2] - 2 * wrap + 2;
1753 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1756 C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][0];
1757 C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][1];
1758 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1759 C[0] = (1 + C[0] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1760 C[1] = (1 + C[1] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1762 if (s->mb_x == s->mb_width - 1) {
1763 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1766 pos_c = s->block_index[3] - 2 * wrap - 2;
1767 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1770 C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][0];
1771 C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][1];
1772 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1773 C[0] = (1 + C[0] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1774 C[1] = (1 + C[1] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1783 pos_b = s->block_index[1];
1785 B[0] = s->current_picture.motion_val[dir][pos_b][0];
1786 B[1] = s->current_picture.motion_val[dir][pos_b][1];
1787 pos_c = s->block_index[0];
1789 C[0] = s->current_picture.motion_val[dir][pos_c][0];
1790 C[1] = s->current_picture.motion_val[dir][pos_c][1];
1793 total_valid = a_valid + b_valid + c_valid;
1794 // check if predictor A is out of bounds
1795 if (!s->mb_x && !(n == 1 || n == 3)) {
1798 // check if predictor B is out of bounds
1799 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1800 B[0] = B[1] = C[0] = C[1] = 0;
1802 if (!v->blk_mv_type[xy]) {
1803 if (s->mb_width == 1) {
1807 if (total_valid >= 2) {
1808 px = mid_pred(A[0], B[0], C[0]);
1809 py = mid_pred(A[1], B[1], C[1]);
1810 } else if (total_valid) {
1811 if (a_valid) { px = A[0]; py = A[1]; }
1812 else if (b_valid) { px = B[0]; py = B[1]; }
1813 else { px = C[0]; py = C[1]; }
1818 field_a = (A[1] & 4) ? 1 : 0;
1822 field_b = (B[1] & 4) ? 1 : 0;
1826 field_c = (C[1] & 4) ? 1 : 0;
1830 num_oppfield = field_a + field_b + field_c;
1831 num_samefield = total_valid - num_oppfield;
1832 if (total_valid == 3) {
1833 if ((num_samefield == 3) || (num_oppfield == 3)) {
1834 px = mid_pred(A[0], B[0], C[0]);
1835 py = mid_pred(A[1], B[1], C[1]);
1836 } else if (num_samefield >= num_oppfield) {
1837 /* take one MV from same field set depending on priority
1838 the check for B may not be necessary */
1839 px = !field_a ? A[0] : B[0];
1840 py = !field_a ? A[1] : B[1];
1842 px = field_a ? A[0] : B[0];
1843 py = field_a ? A[1] : B[1];
1845 } else if (total_valid == 2) {
1846 if (num_samefield >= num_oppfield) {
1847 if (!field_a && a_valid) {
1850 } else if (!field_b && b_valid) {
1853 } else /*if (c_valid)*/ {
1854 av_assert1(c_valid);
1857 } /*else px = py = 0;*/
1859 if (field_a && a_valid) {
1862 } else /*if (field_b && b_valid)*/ {
1863 av_assert1(field_b && b_valid);
1866 } /*else if (c_valid) {
1871 } else if (total_valid == 1) {
1872 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1873 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1877 /* store MV using signed modulus of MV range defined in 4.11 */
1878 s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1879 s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1880 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1881 s->current_picture.motion_val[dir][xy + 1 ][0] = s->current_picture.motion_val[dir][xy][0];
1882 s->current_picture.motion_val[dir][xy + 1 ][1] = s->current_picture.motion_val[dir][xy][1];
1883 s->current_picture.motion_val[dir][xy + wrap ][0] = s->current_picture.motion_val[dir][xy][0];
1884 s->current_picture.motion_val[dir][xy + wrap ][1] = s->current_picture.motion_val[dir][xy][1];
1885 s->current_picture.motion_val[dir][xy + wrap + 1][0] = s->current_picture.motion_val[dir][xy][0];
1886 s->current_picture.motion_val[dir][xy + wrap + 1][1] = s->current_picture.motion_val[dir][xy][1];
1887 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1888 s->current_picture.motion_val[dir][xy + 1][0] = s->current_picture.motion_val[dir][xy][0];
1889 s->current_picture.motion_val[dir][xy + 1][1] = s->current_picture.motion_val[dir][xy][1];
1890 s->mv[dir][n + 1][0] = s->mv[dir][n][0];
1891 s->mv[dir][n + 1][1] = s->mv[dir][n][1];
1895 /** Motion compensation for direct or interpolated blocks in B-frames
1897 static void vc1_interp_mc(VC1Context *v)
1899 MpegEncContext *s = &v->s;
1900 H264ChromaContext *h264chroma = &v->h264chroma;
1901 uint8_t *srcY, *srcU, *srcV;
1902 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1904 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1905 int use_ic = v->next_use_ic;
1907 if (!v->field_mode && !v->s.next_picture.f.data[0])
1910 mx = s->mv[1][0][0];
1911 my = s->mv[1][0][1];
1912 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1913 uvmy = (my + ((my & 3) == 3)) >> 1;
1914 if (v->field_mode) {
1915 if (v->cur_field_type != v->ref_field_type[1])
1916 my = my - 2 + 4 * v->cur_field_type;
1917 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1920 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1921 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1923 srcY = s->next_picture.f.data[0];
1924 srcU = s->next_picture.f.data[1];
1925 srcV = s->next_picture.f.data[2];
1927 src_x = s->mb_x * 16 + (mx >> 2);
1928 src_y = s->mb_y * 16 + (my >> 2);
1929 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1930 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1932 if (v->profile != PROFILE_ADVANCED) {
1933 src_x = av_clip( src_x, -16, s->mb_width * 16);
1934 src_y = av_clip( src_y, -16, s->mb_height * 16);
1935 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1936 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1938 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1939 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1940 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1941 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1944 srcY += src_y * s->linesize + src_x;
1945 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1946 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1948 if (v->field_mode && v->ref_field_type[1]) {
1949 srcY += s->current_picture_ptr->f.linesize[0];
1950 srcU += s->current_picture_ptr->f.linesize[1];
1951 srcV += s->current_picture_ptr->f.linesize[2];
1954 /* for grayscale we should not try to read from unknown area */
1955 if (s->flags & CODEC_FLAG_GRAY) {
1956 srcU = s->edge_emu_buffer + 18 * s->linesize;
1957 srcV = s->edge_emu_buffer + 18 * s->linesize;
1960 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22 || use_ic
1961 || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1962 || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1963 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1965 srcY -= s->mspel * (1 + s->linesize);
1966 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
1967 s->linesize, s->linesize,
1968 17 + s->mspel * 2, 17 + s->mspel * 2,
1969 src_x - s->mspel, src_y - s->mspel,
1970 s->h_edge_pos, v_edge_pos);
1971 srcY = s->edge_emu_buffer;
1972 s->vdsp.emulated_edge_mc(uvbuf, srcU,
1973 s->uvlinesize, s->uvlinesize,
1976 s->h_edge_pos >> 1, v_edge_pos >> 1);
1977 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV,
1978 s->uvlinesize, s->uvlinesize,
1981 s->h_edge_pos >> 1, v_edge_pos >> 1);
1984 /* if we deal with range reduction we need to scale source blocks */
1985 if (v->rangeredfrm) {
1987 uint8_t *src, *src2;
1990 for (j = 0; j < 17 + s->mspel * 2; j++) {
1991 for (i = 0; i < 17 + s->mspel * 2; i++)
1992 src[i] = ((src[i] - 128) >> 1) + 128;
1997 for (j = 0; j < 9; j++) {
1998 for (i = 0; i < 9; i++) {
1999 src[i] = ((src[i] - 128) >> 1) + 128;
2000 src2[i] = ((src2[i] - 128) >> 1) + 128;
2002 src += s->uvlinesize;
2003 src2 += s->uvlinesize;
2008 uint8_t (*luty )[256] = v->next_luty;
2009 uint8_t (*lutuv)[256] = v->next_lutuv;
2011 uint8_t *src, *src2;
2014 for (j = 0; j < 17 + s->mspel * 2; j++) {
2015 int f = v->field_mode ? v->ref_field_type[1] : ((j+src_y - s->mspel) & 1);
2016 for (i = 0; i < 17 + s->mspel * 2; i++)
2017 src[i] = luty[f][src[i]];
2022 for (j = 0; j < 9; j++) {
2023 int f = v->field_mode ? v->ref_field_type[1] : ((j+uvsrc_y) & 1);
2024 for (i = 0; i < 9; i++) {
2025 src[i] = lutuv[f][src[i]];
2026 src2[i] = lutuv[f][src2[i]];
2028 src += s->uvlinesize;
2029 src2 += s->uvlinesize;
2032 srcY += s->mspel * (1 + s->linesize);
2039 dxy = ((my & 3) << 2) | (mx & 3);
2040 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
2041 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
2042 srcY += s->linesize * 8;
2043 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
2044 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
2046 dxy = (my & 2) | ((mx & 2) >> 1);
2049 s->hdsp.avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
2051 s->hdsp.avg_no_rnd_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, 16);
2054 if (s->flags & CODEC_FLAG_GRAY) return;
2055 /* Chroma MC always uses qpel blilinear */
2056 uvmx = (uvmx & 3) << 1;
2057 uvmy = (uvmy & 3) << 1;
2059 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2060 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2062 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2063 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2067 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2071 #if B_FRACTION_DEN==256
2075 return 2 * ((value * n + 255) >> 9);
2076 return (value * n + 128) >> 8;
2079 n -= B_FRACTION_DEN;
2081 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2082 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2086 /** Reconstruct motion vector for B-frame and do motion compensation
2088 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2089 int direct, int mode)
2096 if (mode == BMV_TYPE_INTERPOLATED) {
2102 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2105 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2106 int direct, int mvtype)
2108 MpegEncContext *s = &v->s;
2109 int xy, wrap, off = 0;
2114 const uint8_t *is_intra = v->mb_type[0];
2118 /* scale MV difference to be quad-pel */
2119 dmv_x[0] <<= 1 - s->quarter_sample;
2120 dmv_y[0] <<= 1 - s->quarter_sample;
2121 dmv_x[1] <<= 1 - s->quarter_sample;
2122 dmv_y[1] <<= 1 - s->quarter_sample;
2124 wrap = s->b8_stride;
2125 xy = s->block_index[0];
2128 s->current_picture.motion_val[0][xy + v->blocks_off][0] =
2129 s->current_picture.motion_val[0][xy + v->blocks_off][1] =
2130 s->current_picture.motion_val[1][xy + v->blocks_off][0] =
2131 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
2134 if (!v->field_mode) {
2135 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2136 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2137 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2138 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2140 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2141 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));
2142 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));
2143 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));
2144 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));
2147 s->current_picture.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2148 s->current_picture.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2149 s->current_picture.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2150 s->current_picture.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2154 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2155 C = s->current_picture.motion_val[0][xy - 2];
2156 A = s->current_picture.motion_val[0][xy - wrap * 2];
2157 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2158 B = s->current_picture.motion_val[0][xy - wrap * 2 + off];
2160 if (!s->mb_x) C[0] = C[1] = 0;
2161 if (!s->first_slice_line) { // predictor A is not out of bounds
2162 if (s->mb_width == 1) {
2166 px = mid_pred(A[0], B[0], C[0]);
2167 py = mid_pred(A[1], B[1], C[1]);
2169 } else if (s->mb_x) { // predictor C is not out of bounds
2175 /* Pullback MV as specified in 8.3.5.3.4 */
2178 if (v->profile < PROFILE_ADVANCED) {
2179 qx = (s->mb_x << 5);
2180 qy = (s->mb_y << 5);
2181 X = (s->mb_width << 5) - 4;
2182 Y = (s->mb_height << 5) - 4;
2183 if (qx + px < -28) px = -28 - qx;
2184 if (qy + py < -28) py = -28 - qy;
2185 if (qx + px > X) px = X - qx;
2186 if (qy + py > Y) py = Y - qy;
2188 qx = (s->mb_x << 6);
2189 qy = (s->mb_y << 6);
2190 X = (s->mb_width << 6) - 4;
2191 Y = (s->mb_height << 6) - 4;
2192 if (qx + px < -60) px = -60 - qx;
2193 if (qy + py < -60) py = -60 - qy;
2194 if (qx + px > X) px = X - qx;
2195 if (qy + py > Y) py = Y - qy;
2198 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2199 if (0 && !s->first_slice_line && s->mb_x) {
2200 if (is_intra[xy - wrap])
2201 sum = FFABS(px) + FFABS(py);
2203 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2205 if (get_bits1(&s->gb)) {
2213 if (is_intra[xy - 2])
2214 sum = FFABS(px) + FFABS(py);
2216 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2218 if (get_bits1(&s->gb)) {
2228 /* store MV using signed modulus of MV range defined in 4.11 */
2229 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2230 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2232 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2233 C = s->current_picture.motion_val[1][xy - 2];
2234 A = s->current_picture.motion_val[1][xy - wrap * 2];
2235 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2236 B = s->current_picture.motion_val[1][xy - wrap * 2 + off];
2240 if (!s->first_slice_line) { // predictor A is not out of bounds
2241 if (s->mb_width == 1) {
2245 px = mid_pred(A[0], B[0], C[0]);
2246 py = mid_pred(A[1], B[1], C[1]);
2248 } else if (s->mb_x) { // predictor C is not out of bounds
2254 /* Pullback MV as specified in 8.3.5.3.4 */
2257 if (v->profile < PROFILE_ADVANCED) {
2258 qx = (s->mb_x << 5);
2259 qy = (s->mb_y << 5);
2260 X = (s->mb_width << 5) - 4;
2261 Y = (s->mb_height << 5) - 4;
2262 if (qx + px < -28) px = -28 - qx;
2263 if (qy + py < -28) py = -28 - qy;
2264 if (qx + px > X) px = X - qx;
2265 if (qy + py > Y) py = Y - qy;
2267 qx = (s->mb_x << 6);
2268 qy = (s->mb_y << 6);
2269 X = (s->mb_width << 6) - 4;
2270 Y = (s->mb_height << 6) - 4;
2271 if (qx + px < -60) px = -60 - qx;
2272 if (qy + py < -60) py = -60 - qy;
2273 if (qx + px > X) px = X - qx;
2274 if (qy + py > Y) py = Y - qy;
2277 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2278 if (0 && !s->first_slice_line && s->mb_x) {
2279 if (is_intra[xy - wrap])
2280 sum = FFABS(px) + FFABS(py);
2282 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2284 if (get_bits1(&s->gb)) {
2292 if (is_intra[xy - 2])
2293 sum = FFABS(px) + FFABS(py);
2295 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2297 if (get_bits1(&s->gb)) {
2307 /* store MV using signed modulus of MV range defined in 4.11 */
2309 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2310 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2312 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2313 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2314 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2315 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2318 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2320 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2321 MpegEncContext *s = &v->s;
2322 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2324 if (v->bmvtype == BMV_TYPE_DIRECT) {
2325 int total_opp, k, f;
2326 if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2327 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2328 v->bfraction, 0, s->quarter_sample);
2329 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2330 v->bfraction, 0, s->quarter_sample);
2331 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2332 v->bfraction, 1, s->quarter_sample);
2333 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2334 v->bfraction, 1, s->quarter_sample);
2336 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2337 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2338 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2339 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2340 f = (total_opp > 2) ? 1 : 0;
2342 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2343 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2346 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2347 for (k = 0; k < 4; k++) {
2348 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2349 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2350 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2351 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2352 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2353 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2357 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2358 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);
2359 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);
2362 if (dir) { // backward
2363 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);
2364 if (n == 3 || mv1) {
2365 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2368 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);
2369 if (n == 3 || mv1) {
2370 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2375 /** Get predicted DC value for I-frames only
2376 * prediction dir: left=0, top=1
2377 * @param s MpegEncContext
2378 * @param overlap flag indicating that overlap filtering is used
2379 * @param pq integer part of picture quantizer
2380 * @param[in] n block index in the current MB
2381 * @param dc_val_ptr Pointer to DC predictor
2382 * @param dir_ptr Prediction direction for use in AC prediction
2384 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2385 int16_t **dc_val_ptr, int *dir_ptr)
2387 int a, b, c, wrap, pred, scale;
2389 static const uint16_t dcpred[32] = {
2390 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2391 114, 102, 93, 85, 79, 73, 68, 64,
2392 60, 57, 54, 51, 49, 47, 45, 43,
2393 41, 39, 38, 37, 35, 34, 33
2396 /* find prediction - wmv3_dc_scale always used here in fact */
2397 if (n < 4) scale = s->y_dc_scale;
2398 else scale = s->c_dc_scale;
2400 wrap = s->block_wrap[n];
2401 dc_val = s->dc_val[0] + s->block_index[n];
2407 b = dc_val[ - 1 - wrap];
2408 a = dc_val[ - wrap];
2410 if (pq < 9 || !overlap) {
2411 /* Set outer values */
2412 if (s->first_slice_line && (n != 2 && n != 3))
2413 b = a = dcpred[scale];
2414 if (s->mb_x == 0 && (n != 1 && n != 3))
2415 b = c = dcpred[scale];
2417 /* Set outer values */
2418 if (s->first_slice_line && (n != 2 && n != 3))
2420 if (s->mb_x == 0 && (n != 1 && n != 3))
2424 if (abs(a - b) <= abs(b - c)) {
2426 *dir_ptr = 1; // left
2429 *dir_ptr = 0; // top
2432 /* update predictor */
2433 *dc_val_ptr = &dc_val[0];
2438 /** Get predicted DC value
2439 * prediction dir: left=0, top=1
2440 * @param s MpegEncContext
2441 * @param overlap flag indicating that overlap filtering is used
2442 * @param pq integer part of picture quantizer
2443 * @param[in] n block index in the current MB
2444 * @param a_avail flag indicating top block availability
2445 * @param c_avail flag indicating left block availability
2446 * @param dc_val_ptr Pointer to DC predictor
2447 * @param dir_ptr Prediction direction for use in AC prediction
2449 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2450 int a_avail, int c_avail,
2451 int16_t **dc_val_ptr, int *dir_ptr)
2453 int a, b, c, wrap, pred;
2455 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2459 wrap = s->block_wrap[n];
2460 dc_val = s->dc_val[0] + s->block_index[n];
2466 b = dc_val[ - 1 - wrap];
2467 a = dc_val[ - wrap];
2468 /* scale predictors if needed */
2469 q1 = s->current_picture.qscale_table[mb_pos];
2470 dqscale_index = s->y_dc_scale_table[q1] - 1;
2471 if (dqscale_index < 0)
2473 if (c_avail && (n != 1 && n != 3)) {
2474 q2 = s->current_picture.qscale_table[mb_pos - 1];
2476 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2478 if (a_avail && (n != 2 && n != 3)) {
2479 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2481 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2483 if (a_avail && c_avail && (n != 3)) {
2488 off -= s->mb_stride;
2489 q2 = s->current_picture.qscale_table[off];
2491 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2494 if (a_avail && c_avail) {
2495 if (abs(a - b) <= abs(b - c)) {
2497 *dir_ptr = 1; // left
2500 *dir_ptr = 0; // top
2502 } else if (a_avail) {
2504 *dir_ptr = 0; // top
2505 } else if (c_avail) {
2507 *dir_ptr = 1; // left
2510 *dir_ptr = 1; // left
2513 /* update predictor */
2514 *dc_val_ptr = &dc_val[0];
2518 /** @} */ // Block group
2521 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2522 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2526 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2527 uint8_t **coded_block_ptr)
2529 int xy, wrap, pred, a, b, c;
2531 xy = s->block_index[n];
2532 wrap = s->b8_stride;
2537 a = s->coded_block[xy - 1 ];
2538 b = s->coded_block[xy - 1 - wrap];
2539 c = s->coded_block[xy - wrap];
2548 *coded_block_ptr = &s->coded_block[xy];
2554 * Decode one AC coefficient
2555 * @param v The VC1 context
2556 * @param last Last coefficient
2557 * @param skip How much zero coefficients to skip
2558 * @param value Decoded AC coefficient value
2559 * @param codingset set of VLC to decode data
2562 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2563 int *value, int codingset)
2565 GetBitContext *gb = &v->s.gb;
2566 int index, escape, run = 0, level = 0, lst = 0;
2568 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2569 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2570 run = vc1_index_decode_table[codingset][index][0];
2571 level = vc1_index_decode_table[codingset][index][1];
2572 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2576 escape = decode210(gb);
2578 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2579 run = vc1_index_decode_table[codingset][index][0];
2580 level = vc1_index_decode_table[codingset][index][1];
2581 lst = index >= vc1_last_decode_table[codingset];
2584 level += vc1_last_delta_level_table[codingset][run];
2586 level += vc1_delta_level_table[codingset][run];
2589 run += vc1_last_delta_run_table[codingset][level] + 1;
2591 run += vc1_delta_run_table[codingset][level] + 1;
2597 lst = get_bits1(gb);
2598 if (v->s.esc3_level_length == 0) {
2599 if (v->pq < 8 || v->dquantfrm) { // table 59
2600 v->s.esc3_level_length = get_bits(gb, 3);
2601 if (!v->s.esc3_level_length)
2602 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2603 } else { // table 60
2604 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2606 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2608 run = get_bits(gb, v->s.esc3_run_length);
2609 sign = get_bits1(gb);
2610 level = get_bits(gb, v->s.esc3_level_length);
2621 /** Decode intra block in intra frames - should be faster than decode_intra_block
2622 * @param v VC1Context
2623 * @param block block to decode
2624 * @param[in] n subblock index
2625 * @param coded are AC coeffs present or not
2626 * @param codingset set of VLC to decode data
2628 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
2629 int coded, int codingset)
2631 GetBitContext *gb = &v->s.gb;
2632 MpegEncContext *s = &v->s;
2633 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2636 int16_t *ac_val, *ac_val2;
2639 /* Get DC differential */
2641 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2643 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2646 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2650 if (dcdiff == 119 /* ESC index value */) {
2651 /* TODO: Optimize */
2652 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2653 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2654 else dcdiff = get_bits(gb, 8);
2657 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2658 else if (v->pq == 2)
2659 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2666 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2669 /* Store the quantized DC coeff, used for prediction */
2671 block[0] = dcdiff * s->y_dc_scale;
2673 block[0] = dcdiff * s->c_dc_scale;
2684 int last = 0, skip, value;
2685 const uint8_t *zz_table;
2689 scale = v->pq * 2 + v->halfpq;
2693 zz_table = v->zz_8x8[2];
2695 zz_table = v->zz_8x8[3];
2697 zz_table = v->zz_8x8[1];
2699 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2701 if (dc_pred_dir) // left
2704 ac_val -= 16 * s->block_wrap[n];
2707 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2711 block[zz_table[i++]] = value;
2714 /* apply AC prediction if needed */
2716 if (dc_pred_dir) { // left
2717 for (k = 1; k < 8; k++)
2718 block[k << v->left_blk_sh] += ac_val[k];
2720 for (k = 1; k < 8; k++)
2721 block[k << v->top_blk_sh] += ac_val[k + 8];
2724 /* save AC coeffs for further prediction */
2725 for (k = 1; k < 8; k++) {
2726 ac_val2[k] = block[k << v->left_blk_sh];
2727 ac_val2[k + 8] = block[k << v->top_blk_sh];
2730 /* scale AC coeffs */
2731 for (k = 1; k < 64; k++)
2735 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2738 if (s->ac_pred) i = 63;
2744 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2748 scale = v->pq * 2 + v->halfpq;
2749 memset(ac_val2, 0, 16 * 2);
2750 if (dc_pred_dir) { // left
2753 memcpy(ac_val2, ac_val, 8 * 2);
2755 ac_val -= 16 * s->block_wrap[n];
2757 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2760 /* apply AC prediction if needed */
2762 if (dc_pred_dir) { //left
2763 for (k = 1; k < 8; k++) {
2764 block[k << v->left_blk_sh] = ac_val[k] * scale;
2765 if (!v->pquantizer && block[k << v->left_blk_sh])
2766 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2769 for (k = 1; k < 8; k++) {
2770 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2771 if (!v->pquantizer && block[k << v->top_blk_sh])
2772 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2778 s->block_last_index[n] = i;
2783 /** Decode intra block in intra frames - should be faster than decode_intra_block
2784 * @param v VC1Context
2785 * @param block block to decode
2786 * @param[in] n subblock number
2787 * @param coded are AC coeffs present or not
2788 * @param codingset set of VLC to decode data
2789 * @param mquant quantizer value for this macroblock
2791 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
2792 int coded, int codingset, int mquant)
2794 GetBitContext *gb = &v->s.gb;
2795 MpegEncContext *s = &v->s;
2796 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2798 int16_t *dc_val = NULL;
2799 int16_t *ac_val, *ac_val2;
2801 int a_avail = v->a_avail, c_avail = v->c_avail;
2802 int use_pred = s->ac_pred;
2805 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2807 /* Get DC differential */
2809 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2811 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2814 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2818 if (dcdiff == 119 /* ESC index value */) {
2819 /* TODO: Optimize */
2820 if (mquant == 1) dcdiff = get_bits(gb, 10);
2821 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2822 else dcdiff = get_bits(gb, 8);
2825 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2826 else if (mquant == 2)
2827 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2834 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2837 /* Store the quantized DC coeff, used for prediction */
2839 block[0] = dcdiff * s->y_dc_scale;
2841 block[0] = dcdiff * s->c_dc_scale;
2847 /* check if AC is needed at all */
2848 if (!a_avail && !c_avail)
2850 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2853 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2855 if (dc_pred_dir) // left
2858 ac_val -= 16 * s->block_wrap[n];
2860 q1 = s->current_picture.qscale_table[mb_pos];
2861 if ( dc_pred_dir && c_avail && mb_pos)
2862 q2 = s->current_picture.qscale_table[mb_pos - 1];
2863 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2864 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2865 if ( dc_pred_dir && n == 1)
2867 if (!dc_pred_dir && n == 2)
2873 int last = 0, skip, value;
2874 const uint8_t *zz_table;
2878 if (!use_pred && v->fcm == ILACE_FRAME) {
2879 zz_table = v->zzi_8x8;
2881 if (!dc_pred_dir) // top
2882 zz_table = v->zz_8x8[2];
2884 zz_table = v->zz_8x8[3];
2887 if (v->fcm != ILACE_FRAME)
2888 zz_table = v->zz_8x8[1];
2890 zz_table = v->zzi_8x8;
2894 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2898 block[zz_table[i++]] = value;
2901 /* apply AC prediction if needed */
2903 /* scale predictors if needed*/
2904 if (q2 && q1 != q2) {
2905 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2906 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2909 return AVERROR_INVALIDDATA;
2910 if (dc_pred_dir) { // left
2911 for (k = 1; k < 8; k++)
2912 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2914 for (k = 1; k < 8; k++)
2915 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2918 if (dc_pred_dir) { //left
2919 for (k = 1; k < 8; k++)
2920 block[k << v->left_blk_sh] += ac_val[k];
2922 for (k = 1; k < 8; k++)
2923 block[k << v->top_blk_sh] += ac_val[k + 8];
2927 /* save AC coeffs for further prediction */
2928 for (k = 1; k < 8; k++) {
2929 ac_val2[k ] = block[k << v->left_blk_sh];
2930 ac_val2[k + 8] = block[k << v->top_blk_sh];
2933 /* scale AC coeffs */
2934 for (k = 1; k < 64; k++)
2938 block[k] += (block[k] < 0) ? -mquant : mquant;
2941 if (use_pred) i = 63;
2942 } else { // no AC coeffs
2945 memset(ac_val2, 0, 16 * 2);
2946 if (dc_pred_dir) { // left
2948 memcpy(ac_val2, ac_val, 8 * 2);
2949 if (q2 && q1 != q2) {
2950 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2951 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2953 return AVERROR_INVALIDDATA;
2954 for (k = 1; k < 8; k++)
2955 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2960 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2961 if (q2 && q1 != q2) {
2962 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2963 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2965 return AVERROR_INVALIDDATA;
2966 for (k = 1; k < 8; k++)
2967 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2972 /* apply AC prediction if needed */
2974 if (dc_pred_dir) { // left
2975 for (k = 1; k < 8; k++) {
2976 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2977 if (!v->pquantizer && block[k << v->left_blk_sh])
2978 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2981 for (k = 1; k < 8; k++) {
2982 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2983 if (!v->pquantizer && block[k << v->top_blk_sh])
2984 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2990 s->block_last_index[n] = i;
2995 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2996 * @param v VC1Context
2997 * @param block block to decode
2998 * @param[in] n subblock index
2999 * @param coded are AC coeffs present or not
3000 * @param mquant block quantizer
3001 * @param codingset set of VLC to decode data
3003 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
3004 int coded, int mquant, int codingset)
3006 GetBitContext *gb = &v->s.gb;
3007 MpegEncContext *s = &v->s;
3008 int dc_pred_dir = 0; /* Direction of the DC prediction used */
3010 int16_t *dc_val = NULL;
3011 int16_t *ac_val, *ac_val2;
3013 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3014 int a_avail = v->a_avail, c_avail = v->c_avail;
3015 int use_pred = s->ac_pred;
3019 s->dsp.clear_block(block);
3021 /* XXX: Guard against dumb values of mquant */
3022 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
3024 /* Set DC scale - y and c use the same */
3025 s->y_dc_scale = s->y_dc_scale_table[mquant];
3026 s->c_dc_scale = s->c_dc_scale_table[mquant];
3028 /* Get DC differential */
3030 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3032 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3035 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3039 if (dcdiff == 119 /* ESC index value */) {
3040 /* TODO: Optimize */
3041 if (mquant == 1) dcdiff = get_bits(gb, 10);
3042 else if (mquant == 2) dcdiff = get_bits(gb, 9);
3043 else dcdiff = get_bits(gb, 8);
3046 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
3047 else if (mquant == 2)
3048 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
3055 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3058 /* Store the quantized DC coeff, used for prediction */
3061 block[0] = dcdiff * s->y_dc_scale;
3063 block[0] = dcdiff * s->c_dc_scale;
3069 /* check if AC is needed at all and adjust direction if needed */
3070 if (!a_avail) dc_pred_dir = 1;
3071 if (!c_avail) dc_pred_dir = 0;
3072 if (!a_avail && !c_avail) use_pred = 0;
3073 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3076 scale = mquant * 2 + v->halfpq;
3078 if (dc_pred_dir) //left
3081 ac_val -= 16 * s->block_wrap[n];
3083 q1 = s->current_picture.qscale_table[mb_pos];
3084 if (dc_pred_dir && c_avail && mb_pos)
3085 q2 = s->current_picture.qscale_table[mb_pos - 1];
3086 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3087 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3088 if ( dc_pred_dir && n == 1)
3090 if (!dc_pred_dir && n == 2)
3092 if (n == 3) q2 = q1;
3095 int last = 0, skip, value;
3099 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3103 if (v->fcm == PROGRESSIVE)
3104 block[v->zz_8x8[0][i++]] = value;
3106 if (use_pred && (v->fcm == ILACE_FRAME)) {
3107 if (!dc_pred_dir) // top
3108 block[v->zz_8x8[2][i++]] = value;
3110 block[v->zz_8x8[3][i++]] = value;
3112 block[v->zzi_8x8[i++]] = value;
3117 /* apply AC prediction if needed */
3119 /* scale predictors if needed*/
3120 if (q2 && q1 != q2) {
3121 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3122 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3125 return AVERROR_INVALIDDATA;
3126 if (dc_pred_dir) { // left
3127 for (k = 1; k < 8; k++)
3128 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3130 for (k = 1; k < 8; k++)
3131 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3134 if (dc_pred_dir) { // left
3135 for (k = 1; k < 8; k++)
3136 block[k << v->left_blk_sh] += ac_val[k];
3138 for (k = 1; k < 8; k++)
3139 block[k << v->top_blk_sh] += ac_val[k + 8];
3143 /* save AC coeffs for further prediction */
3144 for (k = 1; k < 8; k++) {
3145 ac_val2[k ] = block[k << v->left_blk_sh];
3146 ac_val2[k + 8] = block[k << v->top_blk_sh];
3149 /* scale AC coeffs */
3150 for (k = 1; k < 64; k++)
3154 block[k] += (block[k] < 0) ? -mquant : mquant;
3157 if (use_pred) i = 63;
3158 } else { // no AC coeffs
3161 memset(ac_val2, 0, 16 * 2);
3162 if (dc_pred_dir) { // left
3164 memcpy(ac_val2, ac_val, 8 * 2);
3165 if (q2 && q1 != q2) {
3166 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3167 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3169 return AVERROR_INVALIDDATA;
3170 for (k = 1; k < 8; k++)
3171 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3176 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3177 if (q2 && q1 != q2) {
3178 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3179 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3181 return AVERROR_INVALIDDATA;
3182 for (k = 1; k < 8; k++)
3183 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3188 /* apply AC prediction if needed */
3190 if (dc_pred_dir) { // left
3191 for (k = 1; k < 8; k++) {
3192 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3193 if (!v->pquantizer && block[k << v->left_blk_sh])
3194 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3197 for (k = 1; k < 8; k++) {
3198 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3199 if (!v->pquantizer && block[k << v->top_blk_sh])
3200 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3206 s->block_last_index[n] = i;
3213 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
3214 int mquant, int ttmb, int first_block,
3215 uint8_t *dst, int linesize, int skip_block,
3218 MpegEncContext *s = &v->s;
3219 GetBitContext *gb = &s->gb;
3222 int scale, off, idx, last, skip, value;
3223 int ttblk = ttmb & 7;
3226 s->dsp.clear_block(block);
3229 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)];
3231 if (ttblk == TT_4X4) {
3232 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3234 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3235 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3236 || (!v->res_rtm_flag && !first_block))) {
3237 subblkpat = decode012(gb);
3239 subblkpat ^= 3; // swap decoded pattern bits
3240 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3242 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3245 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3247 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3248 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3249 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3252 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3253 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3262 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3267 idx = v->zz_8x8[0][i++];
3269 idx = v->zzi_8x8[i++];
3270 block[idx] = value * scale;
3272 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3276 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3278 v->vc1dsp.vc1_inv_trans_8x8(block);
3279 s->dsp.add_pixels_clamped(block, dst, linesize);
3284 pat = ~subblkpat & 0xF;
3285 for (j = 0; j < 4; j++) {
3286 last = subblkpat & (1 << (3 - j));
3288 off = (j & 1) * 4 + (j & 2) * 16;
3290 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3295 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3297 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3298 block[idx + off] = value * scale;
3300 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3302 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3304 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3306 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3311 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3312 for (j = 0; j < 2; j++) {
3313 last = subblkpat & (1 << (1 - j));
3317 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3322 idx = v->zz_8x4[i++] + off;
3324 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3325 block[idx] = value * scale;
3327 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3329 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3331 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3333 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3338 pat = ~(subblkpat * 5) & 0xF;
3339 for (j = 0; j < 2; j++) {
3340 last = subblkpat & (1 << (1 - j));
3344 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3349 idx = v->zz_4x8[i++] + off;
3351 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3352 block[idx] = value * scale;
3354 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3356 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3358 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3360 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3366 *ttmb_out |= ttblk << (n * 4);
3370 /** @} */ // Macroblock group
3372 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3373 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3375 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3377 MpegEncContext *s = &v->s;
3378 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3379 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3380 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3381 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3382 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3385 if (block_num > 3) {
3386 dst = s->dest[block_num - 3];
3388 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3390 if (s->mb_y != s->end_mb_y || block_num < 2) {
3394 if (block_num > 3) {
3395 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3396 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3397 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3398 mv_stride = s->mb_stride;
3400 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3401 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3402 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3403 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3404 mv_stride = s->b8_stride;
3405 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3408 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3409 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3410 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3412 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3414 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3417 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3419 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3424 dst -= 4 * linesize;
3425 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3426 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3427 idx = (block_cbp | (block_cbp >> 2)) & 3;
3429 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3432 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3434 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3439 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3441 MpegEncContext *s = &v->s;
3442 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3443 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3444 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3445 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3446 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3449 if (block_num > 3) {
3450 dst = s->dest[block_num - 3] - 8 * linesize;
3452 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3455 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3458 if (block_num > 3) {
3459 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3460 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3461 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3463 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3464 : (mb_cbp >> ((block_num + 1) * 4));
3465 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3466 : (mb_is_intra >> ((block_num + 1) * 4));
3467 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3469 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3470 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3472 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3474 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3477 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3479 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3485 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3486 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3487 idx = (block_cbp | (block_cbp >> 1)) & 5;
3489 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3492 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3494 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3499 static void vc1_apply_p_loop_filter(VC1Context *v)
3501 MpegEncContext *s = &v->s;
3504 for (i = 0; i < 6; i++) {
3505 vc1_apply_p_v_loop_filter(v, i);
3508 /* V always precedes H, therefore we run H one MB before V;
3509 * at the end of a row, we catch up to complete the row */
3511 for (i = 0; i < 6; i++) {
3512 vc1_apply_p_h_loop_filter(v, i);
3514 if (s->mb_x == s->mb_width - 1) {
3516 ff_update_block_index(s);
3517 for (i = 0; i < 6; i++) {
3518 vc1_apply_p_h_loop_filter(v, i);
3524 /** Decode one P-frame MB
3526 static int vc1_decode_p_mb(VC1Context *v)
3528 MpegEncContext *s = &v->s;
3529 GetBitContext *gb = &s->gb;
3531 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3532 int cbp; /* cbp decoding stuff */
3533 int mqdiff, mquant; /* MB quantization */
3534 int ttmb = v->ttfrm; /* MB Transform type */
3536 int mb_has_coeffs = 1; /* last_flag */
3537 int dmv_x, dmv_y; /* Differential MV components */
3538 int index, index1; /* LUT indexes */
3539 int val, sign; /* temp values */
3540 int first_block = 1;
3542 int skipped, fourmv;
3543 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3545 mquant = v->pq; /* lossy initialization */
3547 if (v->mv_type_is_raw)
3548 fourmv = get_bits1(gb);
3550 fourmv = v->mv_type_mb_plane[mb_pos];
3552 skipped = get_bits1(gb);
3554 skipped = v->s.mbskip_table[mb_pos];
3556 if (!fourmv) { /* 1MV mode */
3558 GET_MVDATA(dmv_x, dmv_y);
3561 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3562 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3564 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3565 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3567 /* FIXME Set DC val for inter block ? */
3568 if (s->mb_intra && !mb_has_coeffs) {
3570 s->ac_pred = get_bits1(gb);
3572 } else if (mb_has_coeffs) {
3574 s->ac_pred = get_bits1(gb);
3575 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3581 s->current_picture.qscale_table[mb_pos] = mquant;
3583 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3584 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3585 VC1_TTMB_VLC_BITS, 2);
3586 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3588 for (i = 0; i < 6; i++) {
3589 s->dc_val[0][s->block_index[i]] = 0;
3591 val = ((cbp >> (5 - i)) & 1);
3592 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3593 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3595 /* check if prediction blocks A and C are available */
3596 v->a_avail = v->c_avail = 0;
3597 if (i == 2 || i == 3 || !s->first_slice_line)
3598 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3599 if (i == 1 || i == 3 || s->mb_x)
3600 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3602 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3603 (i & 4) ? v->codingset2 : v->codingset);
3604 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3606 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3608 for (j = 0; j < 64; j++)
3609 s->block[i][j] <<= 1;
3610 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3611 if (v->pq >= 9 && v->overlap) {
3613 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3615 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3617 block_cbp |= 0xF << (i << 2);
3618 block_intra |= 1 << i;
3620 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3621 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3622 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3623 block_cbp |= pat << (i << 2);
3624 if (!v->ttmbf && ttmb < 8)
3631 for (i = 0; i < 6; i++) {
3632 v->mb_type[0][s->block_index[i]] = 0;
3633 s->dc_val[0][s->block_index[i]] = 0;
3635 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3636 s->current_picture.qscale_table[mb_pos] = 0;
3637 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3640 } else { // 4MV mode
3641 if (!skipped /* unskipped MB */) {
3642 int intra_count = 0, coded_inter = 0;
3643 int is_intra[6], is_coded[6];
3645 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3646 for (i = 0; i < 6; i++) {
3647 val = ((cbp >> (5 - i)) & 1);
3648 s->dc_val[0][s->block_index[i]] = 0;
3655 GET_MVDATA(dmv_x, dmv_y);
3657 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3659 vc1_mc_4mv_luma(v, i, 0, 0);
3660 intra_count += s->mb_intra;
3661 is_intra[i] = s->mb_intra;
3662 is_coded[i] = mb_has_coeffs;
3665 is_intra[i] = (intra_count >= 3);
3669 vc1_mc_4mv_chroma(v, 0);
3670 v->mb_type[0][s->block_index[i]] = is_intra[i];
3672 coded_inter = !is_intra[i] & is_coded[i];
3674 // if there are no coded blocks then don't do anything more
3676 if (!intra_count && !coded_inter)
3679 s->current_picture.qscale_table[mb_pos] = mquant;
3680 /* test if block is intra and has pred */
3683 for (i = 0; i < 6; i++)
3685 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3686 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3692 s->ac_pred = get_bits1(gb);
3696 if (!v->ttmbf && coded_inter)
3697 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3698 for (i = 0; i < 6; i++) {
3700 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3701 s->mb_intra = is_intra[i];
3703 /* check if prediction blocks A and C are available */
3704 v->a_avail = v->c_avail = 0;
3705 if (i == 2 || i == 3 || !s->first_slice_line)
3706 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3707 if (i == 1 || i == 3 || s->mb_x)
3708 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3710 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3711 (i & 4) ? v->codingset2 : v->codingset);
3712 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3714 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3716 for (j = 0; j < 64; j++)
3717 s->block[i][j] <<= 1;
3718 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3719 (i & 4) ? s->uvlinesize : s->linesize);
3720 if (v->pq >= 9 && v->overlap) {
3722 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3724 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3726 block_cbp |= 0xF << (i << 2);
3727 block_intra |= 1 << i;
3728 } else if (is_coded[i]) {
3729 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3730 first_block, s->dest[dst_idx] + off,
3731 (i & 4) ? s->uvlinesize : s->linesize,
3732 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3734 block_cbp |= pat << (i << 2);
3735 if (!v->ttmbf && ttmb < 8)
3740 } else { // skipped MB
3742 s->current_picture.qscale_table[mb_pos] = 0;
3743 for (i = 0; i < 6; i++) {
3744 v->mb_type[0][s->block_index[i]] = 0;
3745 s->dc_val[0][s->block_index[i]] = 0;
3747 for (i = 0; i < 4; i++) {
3748 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3749 vc1_mc_4mv_luma(v, i, 0, 0);
3751 vc1_mc_4mv_chroma(v, 0);
3752 s->current_picture.qscale_table[mb_pos] = 0;
3756 v->cbp[s->mb_x] = block_cbp;
3757 v->ttblk[s->mb_x] = block_tt;
3758 v->is_intra[s->mb_x] = block_intra;
3763 /* Decode one macroblock in an interlaced frame p picture */
3765 static int vc1_decode_p_mb_intfr(VC1Context *v)
3767 MpegEncContext *s = &v->s;
3768 GetBitContext *gb = &s->gb;
3770 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3771 int cbp = 0; /* cbp decoding stuff */
3772 int mqdiff, mquant; /* MB quantization */
3773 int ttmb = v->ttfrm; /* MB Transform type */
3775 int mb_has_coeffs = 1; /* last_flag */
3776 int dmv_x, dmv_y; /* Differential MV components */
3777 int val; /* temp value */
3778 int first_block = 1;
3780 int skipped, fourmv = 0, twomv = 0;
3781 int block_cbp = 0, pat, block_tt = 0;
3782 int idx_mbmode = 0, mvbp;
3783 int stride_y, fieldtx;
3785 mquant = v->pq; /* Lossy initialization */
3788 skipped = get_bits1(gb);
3790 skipped = v->s.mbskip_table[mb_pos];
3792 if (v->fourmvswitch)
3793 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3795 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3796 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3797 /* store the motion vector type in a flag (useful later) */
3798 case MV_PMODE_INTFR_4MV:
3800 v->blk_mv_type[s->block_index[0]] = 0;
3801 v->blk_mv_type[s->block_index[1]] = 0;
3802 v->blk_mv_type[s->block_index[2]] = 0;
3803 v->blk_mv_type[s->block_index[3]] = 0;
3805 case MV_PMODE_INTFR_4MV_FIELD:
3807 v->blk_mv_type[s->block_index[0]] = 1;
3808 v->blk_mv_type[s->block_index[1]] = 1;
3809 v->blk_mv_type[s->block_index[2]] = 1;
3810 v->blk_mv_type[s->block_index[3]] = 1;
3812 case MV_PMODE_INTFR_2MV_FIELD:
3814 v->blk_mv_type[s->block_index[0]] = 1;
3815 v->blk_mv_type[s->block_index[1]] = 1;
3816 v->blk_mv_type[s->block_index[2]] = 1;
3817 v->blk_mv_type[s->block_index[3]] = 1;
3819 case MV_PMODE_INTFR_1MV:
3820 v->blk_mv_type[s->block_index[0]] = 0;
3821 v->blk_mv_type[s->block_index[1]] = 0;
3822 v->blk_mv_type[s->block_index[2]] = 0;
3823 v->blk_mv_type[s->block_index[3]] = 0;
3826 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3827 for (i = 0; i < 4; i++) {
3828 s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
3829 s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
3831 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3832 s->mb_intra = v->is_intra[s->mb_x] = 1;
3833 for (i = 0; i < 6; i++)
3834 v->mb_type[0][s->block_index[i]] = 1;
3835 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3836 mb_has_coeffs = get_bits1(gb);
3838 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3839 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3841 s->current_picture.qscale_table[mb_pos] = mquant;
3842 /* Set DC scale - y and c use the same (not sure if necessary here) */
3843 s->y_dc_scale = s->y_dc_scale_table[mquant];
3844 s->c_dc_scale = s->c_dc_scale_table[mquant];
3846 for (i = 0; i < 6; i++) {
3847 s->dc_val[0][s->block_index[i]] = 0;
3849 val = ((cbp >> (5 - i)) & 1);
3850 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3851 v->a_avail = v->c_avail = 0;
3852 if (i == 2 || i == 3 || !s->first_slice_line)
3853 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3854 if (i == 1 || i == 3 || s->mb_x)
3855 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3857 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3858 (i & 4) ? v->codingset2 : v->codingset);
3859 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3860 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3862 stride_y = s->linesize << fieldtx;
3863 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3865 stride_y = s->uvlinesize;
3868 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3872 } else { // inter MB
3873 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3875 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3876 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3877 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3879 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3880 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3881 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3884 s->mb_intra = v->is_intra[s->mb_x] = 0;
3885 for (i = 0; i < 6; i++)
3886 v->mb_type[0][s->block_index[i]] = 0;
3887 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3888 /* for all motion vector read MVDATA and motion compensate each block */
3892 for (i = 0; i < 6; i++) {
3895 val = ((mvbp >> (3 - i)) & 1);
3897 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3899 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0);
3900 vc1_mc_4mv_luma(v, i, 0, 0);
3901 } else if (i == 4) {
3902 vc1_mc_4mv_chroma4(v, 0, 0, 0);
3909 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3911 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3912 vc1_mc_4mv_luma(v, 0, 0, 0);
3913 vc1_mc_4mv_luma(v, 1, 0, 0);
3916 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3918 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3919 vc1_mc_4mv_luma(v, 2, 0, 0);
3920 vc1_mc_4mv_luma(v, 3, 0, 0);
3921 vc1_mc_4mv_chroma4(v, 0, 0, 0);
3923 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3926 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3928 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3932 GET_MQUANT(); // p. 227
3933 s->current_picture.qscale_table[mb_pos] = mquant;
3934 if (!v->ttmbf && cbp)
3935 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3936 for (i = 0; i < 6; i++) {
3937 s->dc_val[0][s->block_index[i]] = 0;
3939 val = ((cbp >> (5 - i)) & 1);
3941 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3943 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3945 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3946 first_block, s->dest[dst_idx] + off,
3947 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3948 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3949 block_cbp |= pat << (i << 2);
3950 if (!v->ttmbf && ttmb < 8)
3957 s->mb_intra = v->is_intra[s->mb_x] = 0;
3958 for (i = 0; i < 6; i++) {
3959 v->mb_type[0][s->block_index[i]] = 0;
3960 s->dc_val[0][s->block_index[i]] = 0;
3962 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3963 s->current_picture.qscale_table[mb_pos] = 0;
3964 v->blk_mv_type[s->block_index[0]] = 0;
3965 v->blk_mv_type[s->block_index[1]] = 0;
3966 v->blk_mv_type[s->block_index[2]] = 0;
3967 v->blk_mv_type[s->block_index[3]] = 0;
3968 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3971 if (s->mb_x == s->mb_width - 1)
3972 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3976 static int vc1_decode_p_mb_intfi(VC1Context *v)
3978 MpegEncContext *s = &v->s;
3979 GetBitContext *gb = &s->gb;
3981 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3982 int cbp = 0; /* cbp decoding stuff */
3983 int mqdiff, mquant; /* MB quantization */
3984 int ttmb = v->ttfrm; /* MB Transform type */
3986 int mb_has_coeffs = 1; /* last_flag */
3987 int dmv_x, dmv_y; /* Differential MV components */
3988 int val; /* temp values */
3989 int first_block = 1;
3992 int block_cbp = 0, pat, block_tt = 0;
3995 mquant = v->pq; /* Lossy initialization */
3997 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3998 if (idx_mbmode <= 1) { // intra MB
3999 s->mb_intra = v->is_intra[s->mb_x] = 1;
4000 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4001 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4002 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4004 s->current_picture.qscale_table[mb_pos] = mquant;
4005 /* Set DC scale - y and c use the same (not sure if necessary here) */
4006 s->y_dc_scale = s->y_dc_scale_table[mquant];
4007 s->c_dc_scale = s->c_dc_scale_table[mquant];
4008 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4009 mb_has_coeffs = idx_mbmode & 1;
4011 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4013 for (i = 0; i < 6; i++) {
4014 s->dc_val[0][s->block_index[i]] = 0;
4015 v->mb_type[0][s->block_index[i]] = 1;
4017 val = ((cbp >> (5 - i)) & 1);
4018 v->a_avail = v->c_avail = 0;
4019 if (i == 2 || i == 3 || !s->first_slice_line)
4020 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4021 if (i == 1 || i == 3 || s->mb_x)
4022 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4024 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4025 (i & 4) ? v->codingset2 : v->codingset);
4026 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4028 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4029 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4030 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4031 // TODO: loop filter
4034 s->mb_intra = v->is_intra[s->mb_x] = 0;
4035 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4036 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4037 if (idx_mbmode <= 5) { // 1-MV
4038 dmv_x = dmv_y = pred_flag = 0;
4039 if (idx_mbmode & 1) {
4040 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4042 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4044 mb_has_coeffs = !(idx_mbmode & 2);
4046 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4047 for (i = 0; i < 6; i++) {
4049 dmv_x = dmv_y = pred_flag = 0;
4050 val = ((v->fourmvbp >> (3 - i)) & 1);
4052 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4054 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4055 vc1_mc_4mv_luma(v, i, 0, 0);
4057 vc1_mc_4mv_chroma(v, 0);
4059 mb_has_coeffs = idx_mbmode & 1;
4062 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4066 s->current_picture.qscale_table[mb_pos] = mquant;
4067 if (!v->ttmbf && cbp) {
4068 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4071 for (i = 0; i < 6; i++) {
4072 s->dc_val[0][s->block_index[i]] = 0;
4074 val = ((cbp >> (5 - i)) & 1);
4075 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4077 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4078 first_block, s->dest[dst_idx] + off,
4079 (i & 4) ? s->uvlinesize : s->linesize,
4080 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
4082 block_cbp |= pat << (i << 2);
4083 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4088 if (s->mb_x == s->mb_width - 1)
4089 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4093 /** Decode one B-frame MB (in Main profile)
4095 static void vc1_decode_b_mb(VC1Context *v)
4097 MpegEncContext *s = &v->s;
4098 GetBitContext *gb = &s->gb;
4100 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4101 int cbp = 0; /* cbp decoding stuff */
4102 int mqdiff, mquant; /* MB quantization */
4103 int ttmb = v->ttfrm; /* MB Transform type */
4104 int mb_has_coeffs = 0; /* last_flag */
4105 int index, index1; /* LUT indexes */
4106 int val, sign; /* temp values */
4107 int first_block = 1;
4109 int skipped, direct;
4110 int dmv_x[2], dmv_y[2];
4111 int bmvtype = BMV_TYPE_BACKWARD;
4113 mquant = v->pq; /* lossy initialization */
4117 direct = get_bits1(gb);
4119 direct = v->direct_mb_plane[mb_pos];
4121 skipped = get_bits1(gb);
4123 skipped = v->s.mbskip_table[mb_pos];
4125 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4126 for (i = 0; i < 6; i++) {
4127 v->mb_type[0][s->block_index[i]] = 0;
4128 s->dc_val[0][s->block_index[i]] = 0;
4130 s->current_picture.qscale_table[mb_pos] = 0;
4134 GET_MVDATA(dmv_x[0], dmv_y[0]);
4135 dmv_x[1] = dmv_x[0];
4136 dmv_y[1] = dmv_y[0];
4138 if (skipped || !s->mb_intra) {
4139 bmvtype = decode012(gb);
4142 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4145 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4148 bmvtype = BMV_TYPE_INTERPOLATED;
4149 dmv_x[0] = dmv_y[0] = 0;
4153 for (i = 0; i < 6; i++)
4154 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4158 bmvtype = BMV_TYPE_INTERPOLATED;
4159 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4160 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4164 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4167 s->current_picture.qscale_table[mb_pos] = mquant;
4169 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4170 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4171 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4172 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4174 if (!mb_has_coeffs && !s->mb_intra) {
4175 /* no coded blocks - effectively skipped */
4176 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4177 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4180 if (s->mb_intra && !mb_has_coeffs) {
4182 s->current_picture.qscale_table[mb_pos] = mquant;
4183 s->ac_pred = get_bits1(gb);
4185 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4187 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4188 GET_MVDATA(dmv_x[0], dmv_y[0]);
4189 if (!mb_has_coeffs) {
4190 /* interpolated skipped block */
4191 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4192 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4196 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4198 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4201 s->ac_pred = get_bits1(gb);
4202 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4204 s->current_picture.qscale_table[mb_pos] = mquant;
4205 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4206 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4210 for (i = 0; i < 6; i++) {
4211 s->dc_val[0][s->block_index[i]] = 0;
4213 val = ((cbp >> (5 - i)) & 1);
4214 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4215 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4217 /* check if prediction blocks A and C are available */
4218 v->a_avail = v->c_avail = 0;
4219 if (i == 2 || i == 3 || !s->first_slice_line)
4220 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4221 if (i == 1 || i == 3 || s->mb_x)
4222 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4224 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4225 (i & 4) ? v->codingset2 : v->codingset);
4226 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4228 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4230 for (j = 0; j < 64; j++)
4231 s->block[i][j] <<= 1;
4232 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4234 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4235 first_block, s->dest[dst_idx] + off,
4236 (i & 4) ? s->uvlinesize : s->linesize,
4237 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4238 if (!v->ttmbf && ttmb < 8)
4245 /** Decode one B-frame MB (in interlaced field B picture)
4247 static void vc1_decode_b_mb_intfi(VC1Context *v)
4249 MpegEncContext *s = &v->s;
4250 GetBitContext *gb = &s->gb;
4252 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4253 int cbp = 0; /* cbp decoding stuff */
4254 int mqdiff, mquant; /* MB quantization */
4255 int ttmb = v->ttfrm; /* MB Transform type */
4256 int mb_has_coeffs = 0; /* last_flag */
4257 int val; /* temp value */
4258 int first_block = 1;
4261 int dmv_x[2], dmv_y[2], pred_flag[2];
4262 int bmvtype = BMV_TYPE_BACKWARD;
4265 mquant = v->pq; /* Lossy initialization */
4268 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4269 if (idx_mbmode <= 1) { // intra MB
4270 s->mb_intra = v->is_intra[s->mb_x] = 1;
4271 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4272 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4273 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4275 s->current_picture.qscale_table[mb_pos] = mquant;
4276 /* Set DC scale - y and c use the same (not sure if necessary here) */
4277 s->y_dc_scale = s->y_dc_scale_table[mquant];
4278 s->c_dc_scale = s->c_dc_scale_table[mquant];
4279 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4280 mb_has_coeffs = idx_mbmode & 1;
4282 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4284 for (i = 0; i < 6; i++) {
4285 s->dc_val[0][s->block_index[i]] = 0;
4287 val = ((cbp >> (5 - i)) & 1);
4288 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4289 v->a_avail = v->c_avail = 0;
4290 if (i == 2 || i == 3 || !s->first_slice_line)
4291 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4292 if (i == 1 || i == 3 || s->mb_x)
4293 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4295 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4296 (i & 4) ? v->codingset2 : v->codingset);
4297 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4299 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4301 for (j = 0; j < 64; j++)
4302 s->block[i][j] <<= 1;
4303 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4304 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4305 // TODO: yet to perform loop filter
4308 s->mb_intra = v->is_intra[s->mb_x] = 0;
4309 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4310 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4312 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4314 fwd = v->forward_mb_plane[mb_pos];
4315 if (idx_mbmode <= 5) { // 1-MV
4317 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4318 pred_flag[0] = pred_flag[1] = 0;
4320 bmvtype = BMV_TYPE_FORWARD;
4322 bmvtype = decode012(gb);
4325 bmvtype = BMV_TYPE_BACKWARD;
4328 bmvtype = BMV_TYPE_DIRECT;
4331 bmvtype = BMV_TYPE_INTERPOLATED;
4332 interpmvp = get_bits1(gb);
4335 v->bmvtype = bmvtype;
4336 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4337 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4340 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4342 if (bmvtype == BMV_TYPE_DIRECT) {
4343 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4344 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4346 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4347 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4348 mb_has_coeffs = !(idx_mbmode & 2);
4351 bmvtype = BMV_TYPE_FORWARD;
4352 v->bmvtype = bmvtype;
4353 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4354 for (i = 0; i < 6; i++) {
4356 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4357 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4358 val = ((v->fourmvbp >> (3 - i)) & 1);
4360 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4361 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4362 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4364 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4365 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD, 0);
4367 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4369 mb_has_coeffs = idx_mbmode & 1;
4372 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4376 s->current_picture.qscale_table[mb_pos] = mquant;
4377 if (!v->ttmbf && cbp) {
4378 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4381 for (i = 0; i < 6; i++) {
4382 s->dc_val[0][s->block_index[i]] = 0;
4384 val = ((cbp >> (5 - i)) & 1);
4385 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4387 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4388 first_block, s->dest[dst_idx] + off,
4389 (i & 4) ? s->uvlinesize : s->linesize,
4390 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4391 if (!v->ttmbf && ttmb < 8)
4399 /** Decode one B-frame MB (in interlaced frame B picture)
4401 static int vc1_decode_b_mb_intfr(VC1Context *v)
4403 MpegEncContext *s = &v->s;
4404 GetBitContext *gb = &s->gb;
4406 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4407 int cbp = 0; /* cbp decoding stuff */
4408 int mqdiff, mquant; /* MB quantization */
4409 int ttmb = v->ttfrm; /* MB Transform type */
4410 int mvsw = 0; /* motion vector switch */
4411 int mb_has_coeffs = 1; /* last_flag */
4412 int dmv_x, dmv_y; /* Differential MV components */
4413 int val; /* temp value */
4414 int first_block = 1;
4416 int skipped, direct, twomv = 0;
4417 int block_cbp = 0, pat, block_tt = 0;
4418 int idx_mbmode = 0, mvbp;
4419 int stride_y, fieldtx;
4420 int bmvtype = BMV_TYPE_BACKWARD;
4423 mquant = v->pq; /* Lossy initialization */
4426 skipped = get_bits1(gb);
4428 skipped = v->s.mbskip_table[mb_pos];
4431 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
4432 if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
4434 v->blk_mv_type[s->block_index[0]] = 1;
4435 v->blk_mv_type[s->block_index[1]] = 1;
4436 v->blk_mv_type[s->block_index[2]] = 1;
4437 v->blk_mv_type[s->block_index[3]] = 1;
4439 v->blk_mv_type[s->block_index[0]] = 0;
4440 v->blk_mv_type[s->block_index[1]] = 0;
4441 v->blk_mv_type[s->block_index[2]] = 0;
4442 v->blk_mv_type[s->block_index[3]] = 0;
4447 direct = get_bits1(gb);
4449 direct = v->direct_mb_plane[mb_pos];
4452 s->mv[0][0][0] = s->current_picture.motion_val[0][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 0, s->quarter_sample);
4453 s->mv[0][0][1] = s->current_picture.motion_val[0][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 0, s->quarter_sample);
4454 s->mv[1][0][0] = s->current_picture.motion_val[1][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 1, s->quarter_sample);
4455 s->mv[1][0][1] = s->current_picture.motion_val[1][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 1, s->quarter_sample);
4458 s->mv[0][2][0] = s->current_picture.motion_val[0][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 0, s->quarter_sample);
4459 s->mv[0][2][1] = s->current_picture.motion_val[0][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 0, s->quarter_sample);
4460 s->mv[1][2][0] = s->current_picture.motion_val[1][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 1, s->quarter_sample);
4461 s->mv[1][2][1] = s->current_picture.motion_val[1][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 1, s->quarter_sample);
4463 for (i = 1; i < 4; i += 2) {
4464 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
4465 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
4466 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
4467 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
4470 for (i = 1; i < 4; i++) {
4471 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
4472 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
4473 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
4474 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
4479 if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
4480 for (i = 0; i < 4; i++) {
4481 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;
4482 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;
4483 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
4484 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
4486 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4487 s->mb_intra = v->is_intra[s->mb_x] = 1;
4488 for (i = 0; i < 6; i++)
4489 v->mb_type[0][s->block_index[i]] = 1;
4490 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
4491 mb_has_coeffs = get_bits1(gb);
4493 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4494 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4496 s->current_picture.qscale_table[mb_pos] = mquant;
4497 /* Set DC scale - y and c use the same (not sure if necessary here) */
4498 s->y_dc_scale = s->y_dc_scale_table[mquant];
4499 s->c_dc_scale = s->c_dc_scale_table[mquant];
4501 for (i = 0; i < 6; i++) {
4502 s->dc_val[0][s->block_index[i]] = 0;
4504 val = ((cbp >> (5 - i)) & 1);
4505 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4506 v->a_avail = v->c_avail = 0;
4507 if (i == 2 || i == 3 || !s->first_slice_line)
4508 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4509 if (i == 1 || i == 3 || s->mb_x)
4510 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4512 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4513 (i & 4) ? v->codingset2 : v->codingset);
4514 if (i > 3 && (s->flags & CODEC_FLAG_GRAY))
4516 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4518 stride_y = s->linesize << fieldtx;
4519 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
4521 stride_y = s->uvlinesize;
4524 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
4527 s->mb_intra = v->is_intra[s->mb_x] = 0;
4529 if (skipped || !s->mb_intra) {
4530 bmvtype = decode012(gb);
4533 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4536 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4539 bmvtype = BMV_TYPE_INTERPOLATED;
4543 if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
4544 mvsw = get_bits1(gb);
4547 if (!skipped) { // inter MB
4548 mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
4550 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4552 if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
4553 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4554 } else if (bmvtype == BMV_TYPE_INTERPOLATED || twomv) {
4555 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
4559 for (i = 0; i < 6; i++)
4560 v->mb_type[0][s->block_index[i]] = 0;
4561 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1];
4562 /* for all motion vector read MVDATA and motion compensate each block */
4566 for (i = 0; i < 4; i++) {
4567 vc1_mc_4mv_luma(v, i, 0, 0);
4568 vc1_mc_4mv_luma(v, i, 1, 1);
4570 vc1_mc_4mv_chroma4(v, 0, 0, 0);
4571 vc1_mc_4mv_chroma4(v, 1, 1, 1);
4576 } else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) {
4578 for (i = 0; i < 4; i++) {
4581 val = ((mvbp >> (3 - i)) & 1);
4583 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4585 vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4586 vc1_mc_4mv_luma(v, j, dir, dir);
4587 vc1_mc_4mv_luma(v, j+1, dir, dir);
4590 vc1_mc_4mv_chroma4(v, 0, 0, 0);
4591 vc1_mc_4mv_chroma4(v, 1, 1, 1);
4592 } else if (bmvtype == BMV_TYPE_INTERPOLATED) {
4596 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4598 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4603 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4605 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4608 dir = bmvtype == BMV_TYPE_BACKWARD;
4615 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4616 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4620 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4621 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir2);
4624 for (i = 0; i < 2; i++) {
4625 s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];
4626 s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];
4627 s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];
4628 s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];
4631 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4632 vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4635 vc1_mc_4mv_luma(v, 0, dir, 0);
4636 vc1_mc_4mv_luma(v, 1, dir, 0);
4637 vc1_mc_4mv_luma(v, 2, dir2, 0);
4638 vc1_mc_4mv_luma(v, 3, dir2, 0);
4639 vc1_mc_4mv_chroma4(v, dir, dir2, 0);
4641 dir = bmvtype == BMV_TYPE_BACKWARD;
4643 mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2];
4646 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4648 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4649 v->blk_mv_type[s->block_index[0]] = 1;
4650 v->blk_mv_type[s->block_index[1]] = 1;
4651 v->blk_mv_type[s->block_index[2]] = 1;
4652 v->blk_mv_type[s->block_index[3]] = 1;
4653 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4654 for (i = 0; i < 2; i++) {
4655 s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];
4656 s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];
4662 GET_MQUANT(); // p. 227
4663 s->current_picture.qscale_table[mb_pos] = mquant;
4664 if (!v->ttmbf && cbp)
4665 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4666 for (i = 0; i < 6; i++) {
4667 s->dc_val[0][s->block_index[i]] = 0;
4669 val = ((cbp >> (5 - i)) & 1);
4671 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4673 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
4675 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4676 first_block, s->dest[dst_idx] + off,
4677 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
4678 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
4679 block_cbp |= pat << (i << 2);
4680 if (!v->ttmbf && ttmb < 8)
4688 for (i = 0; i < 6; i++) {
4689 v->mb_type[0][s->block_index[i]] = 0;
4690 s->dc_val[0][s->block_index[i]] = 0;
4692 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
4693 s->current_picture.qscale_table[mb_pos] = 0;
4694 v->blk_mv_type[s->block_index[0]] = 0;
4695 v->blk_mv_type[s->block_index[1]] = 0;
4696 v->blk_mv_type[s->block_index[2]] = 0;
4697 v->blk_mv_type[s->block_index[3]] = 0;
4700 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4701 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4702 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4704 dir = bmvtype == BMV_TYPE_BACKWARD;
4705 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4710 for (i = 0; i < 2; i++) {
4711 s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];
4712 s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];
4713 s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];
4714 s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];
4717 v->blk_mv_type[s->block_index[0]] = 1;
4718 v->blk_mv_type[s->block_index[1]] = 1;
4719 v->blk_mv_type[s->block_index[2]] = 1;
4720 v->blk_mv_type[s->block_index[3]] = 1;
4721 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4722 for (i = 0; i < 2; i++) {
4723 s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];
4724 s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];
4731 if (direct || bmvtype == BMV_TYPE_INTERPOLATED) {
4736 if (s->mb_x == s->mb_width - 1)
4737 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4738 v->cbp[s->mb_x] = block_cbp;
4739 v->ttblk[s->mb_x] = block_tt;
4743 /** Decode blocks of I-frame
4745 static void vc1_decode_i_blocks(VC1Context *v)
4748 MpegEncContext *s = &v->s;
4753 /* select codingmode used for VLC tables selection */
4754 switch (v->y_ac_table_index) {
4756 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4759 v->codingset = CS_HIGH_MOT_INTRA;
4762 v->codingset = CS_MID_RATE_INTRA;
4766 switch (v->c_ac_table_index) {
4768 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4771 v->codingset2 = CS_HIGH_MOT_INTER;
4774 v->codingset2 = CS_MID_RATE_INTER;
4778 /* Set DC scale - y and c use the same */
4779 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4780 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4783 s->mb_x = s->mb_y = 0;
4785 s->first_slice_line = 1;
4786 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4788 init_block_index(v);
4789 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4791 ff_update_block_index(s);
4792 dst[0] = s->dest[0];
4793 dst[1] = dst[0] + 8;
4794 dst[2] = s->dest[0] + s->linesize * 8;
4795 dst[3] = dst[2] + 8;
4796 dst[4] = s->dest[1];
4797 dst[5] = s->dest[2];
4798 s->dsp.clear_blocks(s->block[0]);
4799 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4800 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4801 s->current_picture.qscale_table[mb_pos] = v->pq;
4802 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4803 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4805 // do actual MB decoding and displaying
4806 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4807 v->s.ac_pred = get_bits1(&v->s.gb);
4809 for (k = 0; k < 6; k++) {
4810 val = ((cbp >> (5 - k)) & 1);
4813 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4817 cbp |= val << (5 - k);
4819 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4821 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4823 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4824 if (v->pq >= 9 && v->overlap) {
4826 for (j = 0; j < 64; j++)
4827 s->block[k][j] <<= 1;
4828 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4831 for (j = 0; j < 64; j++)
4832 s->block[k][j] = (s->block[k][j] - 64) << 1;
4833 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4837 if (v->pq >= 9 && v->overlap) {
4839 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4840 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4841 if (!(s->flags & CODEC_FLAG_GRAY)) {
4842 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4843 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4846 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4847 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4848 if (!s->first_slice_line) {
4849 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4850 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4851 if (!(s->flags & CODEC_FLAG_GRAY)) {
4852 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4853 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4856 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4857 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4859 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4861 if (get_bits_count(&s->gb) > v->bits) {
4862 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4863 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4864 get_bits_count(&s->gb), v->bits);
4868 if (!v->s.loop_filter)
4869 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4871 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4873 s->first_slice_line = 0;
4875 if (v->s.loop_filter)
4876 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4878 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4879 * profile, these only differ are when decoding MSS2 rectangles. */
4880 ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4883 /** Decode blocks of I-frame for advanced profile
4885 static void vc1_decode_i_blocks_adv(VC1Context *v)
4888 MpegEncContext *s = &v->s;
4894 GetBitContext *gb = &s->gb;
4896 /* select codingmode used for VLC tables selection */
4897 switch (v->y_ac_table_index) {
4899 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4902 v->codingset = CS_HIGH_MOT_INTRA;
4905 v->codingset = CS_MID_RATE_INTRA;
4909 switch (v->c_ac_table_index) {
4911 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4914 v->codingset2 = CS_HIGH_MOT_INTER;
4917 v->codingset2 = CS_MID_RATE_INTER;
4922 s->mb_x = s->mb_y = 0;
4924 s->first_slice_line = 1;
4925 s->mb_y = s->start_mb_y;
4926 if (s->start_mb_y) {
4928 init_block_index(v);
4929 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4930 (1 + s->b8_stride) * sizeof(*s->coded_block));
4932 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4934 init_block_index(v);
4935 for (;s->mb_x < s->mb_width; s->mb_x++) {
4936 int16_t (*block)[64] = v->block[v->cur_blk_idx];
4937 ff_update_block_index(s);
4938 s->dsp.clear_blocks(block[0]);
4939 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4940 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4941 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4942 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4944 // do actual MB decoding and displaying
4945 if (v->fieldtx_is_raw)
4946 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4947 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4948 if ( v->acpred_is_raw)
4949 v->s.ac_pred = get_bits1(&v->s.gb);
4951 v->s.ac_pred = v->acpred_plane[mb_pos];
4953 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4954 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4958 s->current_picture.qscale_table[mb_pos] = mquant;
4959 /* Set DC scale - y and c use the same */
4960 s->y_dc_scale = s->y_dc_scale_table[mquant];
4961 s->c_dc_scale = s->c_dc_scale_table[mquant];
4963 for (k = 0; k < 6; k++) {
4964 val = ((cbp >> (5 - k)) & 1);
4967 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4971 cbp |= val << (5 - k);
4973 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4974 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4976 vc1_decode_i_block_adv(v, block[k], k, val,
4977 (k < 4) ? v->codingset : v->codingset2, mquant);
4979 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4981 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4984 vc1_smooth_overlap_filter_iblk(v);
4985 vc1_put_signed_blocks_clamped(v);
4986 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4988 if (get_bits_count(&s->gb) > v->bits) {
4989 // TODO: may need modification to handle slice coding
4990 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4991 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4992 get_bits_count(&s->gb), v->bits);
4996 if (!v->s.loop_filter)
4997 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4999 ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
5000 s->first_slice_line = 0;
5003 /* raw bottom MB row */
5005 init_block_index(v);
5007 for (;s->mb_x < s->mb_width; s->mb_x++) {
5008 ff_update_block_index(s);
5009 vc1_put_signed_blocks_clamped(v);
5010 if (v->s.loop_filter)
5011 vc1_loop_filter_iblk_delayed(v, v->pq);
5013 if (v->s.loop_filter)
5014 ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
5015 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5016 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5019 static void vc1_decode_p_blocks(VC1Context *v)
5021 MpegEncContext *s = &v->s;
5022 int apply_loop_filter;
5024 /* select codingmode used for VLC tables selection */
5025 switch (v->c_ac_table_index) {
5027 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5030 v->codingset = CS_HIGH_MOT_INTRA;
5033 v->codingset = CS_MID_RATE_INTRA;
5037 switch (v->c_ac_table_index) {
5039 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5042 v->codingset2 = CS_HIGH_MOT_INTER;
5045 v->codingset2 = CS_MID_RATE_INTER;
5049 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY) &&
5050 v->fcm == PROGRESSIVE;
5051 s->first_slice_line = 1;
5052 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
5053 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5055 init_block_index(v);
5056 for (; s->mb_x < s->mb_width; s->mb_x++) {
5057 ff_update_block_index(s);
5059 if (v->fcm == ILACE_FIELD)
5060 vc1_decode_p_mb_intfi(v);
5061 else if (v->fcm == ILACE_FRAME)
5062 vc1_decode_p_mb_intfr(v);
5063 else vc1_decode_p_mb(v);
5064 if (s->mb_y != s->start_mb_y && apply_loop_filter)
5065 vc1_apply_p_loop_filter(v);
5066 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5067 // TODO: may need modification to handle slice coding
5068 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5069 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5070 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5074 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
5075 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
5076 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
5077 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
5078 if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5079 s->first_slice_line = 0;
5081 if (apply_loop_filter) {
5083 init_block_index(v);
5084 for (; s->mb_x < s->mb_width; s->mb_x++) {
5085 ff_update_block_index(s);
5086 vc1_apply_p_loop_filter(v);
5089 if (s->end_mb_y >= s->start_mb_y)
5090 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5091 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5092 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5095 static void vc1_decode_b_blocks(VC1Context *v)
5097 MpegEncContext *s = &v->s;
5099 /* select codingmode used for VLC tables selection */
5100 switch (v->c_ac_table_index) {
5102 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5105 v->codingset = CS_HIGH_MOT_INTRA;
5108 v->codingset = CS_MID_RATE_INTRA;
5112 switch (v->c_ac_table_index) {
5114 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5117 v->codingset2 = CS_HIGH_MOT_INTER;
5120 v->codingset2 = CS_MID_RATE_INTER;
5124 s->first_slice_line = 1;
5125 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5127 init_block_index(v);
5128 for (; s->mb_x < s->mb_width; s->mb_x++) {
5129 ff_update_block_index(s);
5131 if (v->fcm == ILACE_FIELD)
5132 vc1_decode_b_mb_intfi(v);
5133 else if (v->fcm == ILACE_FRAME)
5134 vc1_decode_b_mb_intfr(v);
5137 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5138 // TODO: may need modification to handle slice coding
5139 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5140 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5141 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5144 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
5146 if (!v->s.loop_filter)
5147 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5149 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5150 s->first_slice_line = 0;
5152 if (v->s.loop_filter)
5153 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5154 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5155 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5158 static void vc1_decode_skip_blocks(VC1Context *v)
5160 MpegEncContext *s = &v->s;
5162 if (!v->s.last_picture.f.data[0])
5165 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
5166 s->first_slice_line = 1;
5167 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5169 init_block_index(v);
5170 ff_update_block_index(s);
5171 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
5172 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5173 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5174 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5175 s->first_slice_line = 0;
5177 s->pict_type = AV_PICTURE_TYPE_P;
5180 void ff_vc1_decode_blocks(VC1Context *v)
5183 v->s.esc3_level_length = 0;
5185 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
5188 v->left_blk_idx = -1;
5189 v->topleft_blk_idx = 1;
5191 switch (v->s.pict_type) {
5192 case AV_PICTURE_TYPE_I:
5193 if (v->profile == PROFILE_ADVANCED)
5194 vc1_decode_i_blocks_adv(v);
5196 vc1_decode_i_blocks(v);
5198 case AV_PICTURE_TYPE_P:
5199 if (v->p_frame_skipped)
5200 vc1_decode_skip_blocks(v);
5202 vc1_decode_p_blocks(v);
5204 case AV_PICTURE_TYPE_B:
5206 if (v->profile == PROFILE_ADVANCED)
5207 vc1_decode_i_blocks_adv(v);
5209 vc1_decode_i_blocks(v);
5211 vc1_decode_b_blocks(v);
5217 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5221 * Transform coefficients for both sprites in 16.16 fixed point format,
5222 * in the order they appear in the bitstream:
5224 * rotation 1 (unused)
5226 * rotation 2 (unused)
5233 int effect_type, effect_flag;
5234 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
5235 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
5238 static inline int get_fp_val(GetBitContext* gb)
5240 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
5243 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
5247 switch (get_bits(gb, 2)) {
5250 c[2] = get_fp_val(gb);
5254 c[0] = c[4] = get_fp_val(gb);
5255 c[2] = get_fp_val(gb);
5258 c[0] = get_fp_val(gb);
5259 c[2] = get_fp_val(gb);
5260 c[4] = get_fp_val(gb);
5263 c[0] = get_fp_val(gb);
5264 c[1] = get_fp_val(gb);
5265 c[2] = get_fp_val(gb);
5266 c[3] = get_fp_val(gb);
5267 c[4] = get_fp_val(gb);
5270 c[5] = get_fp_val(gb);
5272 c[6] = get_fp_val(gb);
5277 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
5279 AVCodecContext *avctx = v->s.avctx;
5282 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5283 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
5284 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
5285 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
5286 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
5287 for (i = 0; i < 7; i++)
5288 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
5289 sd->coefs[sprite][i] / (1<<16),
5290 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
5291 av_log(avctx, AV_LOG_DEBUG, "\n");
5295 if (sd->effect_type = get_bits_long(gb, 30)) {
5296 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
5298 vc1_sprite_parse_transform(gb, sd->effect_params1);
5301 vc1_sprite_parse_transform(gb, sd->effect_params1);
5302 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
5305 for (i = 0; i < sd->effect_pcount1; i++)
5306 sd->effect_params1[i] = get_fp_val(gb);
5308 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
5309 // effect 13 is simple alpha blending and matches the opacity above
5310 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
5311 for (i = 0; i < sd->effect_pcount1; i++)
5312 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5313 sd->effect_params1[i] / (1 << 16),
5314 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
5315 av_log(avctx, AV_LOG_DEBUG, "\n");
5318 sd->effect_pcount2 = get_bits(gb, 16);
5319 if (sd->effect_pcount2 > 10) {
5320 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
5321 return AVERROR_INVALIDDATA;
5322 } else if (sd->effect_pcount2) {
5324 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
5325 while (++i < sd->effect_pcount2) {
5326 sd->effect_params2[i] = get_fp_val(gb);
5327 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5328 sd->effect_params2[i] / (1 << 16),
5329 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
5331 av_log(avctx, AV_LOG_DEBUG, "\n");
5334 if (sd->effect_flag = get_bits1(gb))
5335 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
5337 if (get_bits_count(gb) >= gb->size_in_bits +
5338 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
5339 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
5340 return AVERROR_INVALIDDATA;
5342 if (get_bits_count(gb) < gb->size_in_bits - 8)
5343 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
5348 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
5350 int i, plane, row, sprite;
5351 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
5352 uint8_t* src_h[2][2];
5353 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
5355 MpegEncContext *s = &v->s;
5357 for (i = 0; i <= v->two_sprites; i++) {
5358 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
5359 xadv[i] = sd->coefs[i][0];
5360 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
5361 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
5363 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
5364 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
5366 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
5368 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
5369 int width = v->output_width>>!!plane;
5371 for (row = 0; row < v->output_height>>!!plane; row++) {
5372 uint8_t *dst = v->sprite_output_frame->data[plane] +
5373 v->sprite_output_frame->linesize[plane] * row;
5375 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5376 uint8_t *iplane = s->current_picture.f.data[plane];
5377 int iline = s->current_picture.f.linesize[plane];
5378 int ycoord = yoff[sprite] + yadv[sprite] * row;
5379 int yline = ycoord >> 16;
5381 ysub[sprite] = ycoord & 0xFFFF;
5383 iplane = s->last_picture.f.data[plane];
5384 iline = s->last_picture.f.linesize[plane];
5386 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
5387 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
5388 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
5390 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
5392 if (sr_cache[sprite][0] != yline) {
5393 if (sr_cache[sprite][1] == yline) {
5394 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
5395 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
5397 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
5398 sr_cache[sprite][0] = yline;
5401 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
5402 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
5403 iplane + next_line, xoff[sprite],
5404 xadv[sprite], width);
5405 sr_cache[sprite][1] = yline + 1;
5407 src_h[sprite][0] = v->sr_rows[sprite][0];
5408 src_h[sprite][1] = v->sr_rows[sprite][1];
5412 if (!v->two_sprites) {
5414 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
5416 memcpy(dst, src_h[0][0], width);
5419 if (ysub[0] && ysub[1]) {
5420 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5421 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5422 } else if (ysub[0]) {
5423 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5424 src_h[1][0], alpha, width);
5425 } else if (ysub[1]) {
5426 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5427 src_h[0][0], (1<<16)-1-alpha, width);
5429 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5435 for (i = 0; i <= v->two_sprites; i++) {
5445 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5448 MpegEncContext *s = &v->s;
5449 AVCodecContext *avctx = s->avctx;
5452 memset(&sd, 0, sizeof(sd));
5454 ret = vc1_parse_sprites(v, gb, &sd);
5458 if (!s->current_picture.f.data[0]) {
5459 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5463 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5464 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5468 av_frame_unref(v->sprite_output_frame);
5469 if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
5472 vc1_draw_sprites(v, &sd);
5477 static void vc1_sprite_flush(AVCodecContext *avctx)
5479 VC1Context *v = avctx->priv_data;
5480 MpegEncContext *s = &v->s;
5481 AVFrame *f = &s->current_picture.f;
5484 /* Windows Media Image codecs have a convergence interval of two keyframes.
5485 Since we can't enforce it, clear to black the missing sprite. This is
5486 wrong but it looks better than doing nothing. */
5489 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5490 for (i = 0; i < v->sprite_height>>!!plane; i++)
5491 memset(f->data[plane] + i * f->linesize[plane],
5492 plane ? 128 : 0, f->linesize[plane]);
5497 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5499 MpegEncContext *s = &v->s;
5501 int mb_height = FFALIGN(s->mb_height, 2);
5503 /* Allocate mb bitplanes */
5504 v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
5505 v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
5506 v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
5507 v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
5508 v->acpred_plane = av_malloc (s->mb_stride * mb_height);
5509 v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
5511 v->n_allocated_blks = s->mb_width + 2;
5512 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5513 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5514 v->cbp = v->cbp_base + s->mb_stride;
5515 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5516 v->ttblk = v->ttblk_base + s->mb_stride;
5517 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5518 v->is_intra = v->is_intra_base + s->mb_stride;
5519 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5520 v->luma_mv = v->luma_mv_base + s->mb_stride;
5522 /* allocate block type info in that way so it could be used with s->block_index[] */
5523 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5524 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5525 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
5526 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
5528 /* allocate memory to store block level MV info */
5529 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5530 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5531 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
5532 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5533 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5534 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
5535 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5536 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5538 /* Init coded blocks info */
5539 if (v->profile == PROFILE_ADVANCED) {
5540 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5542 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5546 ff_intrax8_common_init(&v->x8,s);
5548 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5549 for (i = 0; i < 4; i++)
5550 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
5551 return AVERROR(ENOMEM);
5554 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5555 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5557 av_freep(&v->mv_type_mb_plane);
5558 av_freep(&v->direct_mb_plane);
5559 av_freep(&v->acpred_plane);
5560 av_freep(&v->over_flags_plane);
5561 av_freep(&v->block);
5562 av_freep(&v->cbp_base);
5563 av_freep(&v->ttblk_base);
5564 av_freep(&v->is_intra_base);
5565 av_freep(&v->luma_mv_base);
5566 av_freep(&v->mb_type_base);
5567 return AVERROR(ENOMEM);
5573 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5576 for (i = 0; i < 64; i++) {
5577 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5578 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5579 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5580 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5581 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5582 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5588 /** Initialize a VC1/WMV3 decoder
5589 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5590 * @todo TODO: Decypher remaining bits in extra_data
5592 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5594 VC1Context *v = avctx->priv_data;
5595 MpegEncContext *s = &v->s;
5599 /* save the container output size for WMImage */
5600 v->output_width = avctx->width;
5601 v->output_height = avctx->height;
5603 if (!avctx->extradata_size || !avctx->extradata)
5605 if (!(avctx->flags & CODEC_FLAG_GRAY))
5606 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5608 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5609 avctx->hwaccel = ff_find_hwaccel(avctx);
5612 if ((ret = ff_vc1_init_common(v)) < 0)
5614 // ensure static VLC tables are initialized
5615 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
5617 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
5619 // Hack to ensure the above functions will be called
5620 // again once we know all necessary settings.
5621 // That this is necessary might indicate a bug.
5622 ff_vc1_decode_end(avctx);
5624 ff_h264chroma_init(&v->h264chroma, 8);
5625 ff_vc1dsp_init(&v->vc1dsp);
5627 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5630 // looks like WMV3 has a sequence header stored in the extradata
5631 // advanced sequence header may be before the first frame
5632 // the last byte of the extradata is a version number, 1 for the
5633 // samples we can decode
5635 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5637 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
5640 count = avctx->extradata_size*8 - get_bits_count(&gb);
5642 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5643 count, get_bits(&gb, count));
5644 } else if (count < 0) {
5645 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5647 } else { // VC1/WVC1/WVP2
5648 const uint8_t *start = avctx->extradata;
5649 uint8_t *end = avctx->extradata + avctx->extradata_size;
5650 const uint8_t *next;
5651 int size, buf2_size;
5652 uint8_t *buf2 = NULL;
5653 int seq_initialized = 0, ep_initialized = 0;
5655 if (avctx->extradata_size < 16) {
5656 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5660 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5661 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5663 for (; next < end; start = next) {
5664 next = find_next_marker(start + 4, end);
5665 size = next - start - 4;
5668 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5669 init_get_bits(&gb, buf2, buf2_size * 8);
5670 switch (AV_RB32(start)) {
5671 case VC1_CODE_SEQHDR:
5672 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
5676 seq_initialized = 1;
5678 case VC1_CODE_ENTRYPOINT:
5679 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
5688 if (!seq_initialized || !ep_initialized) {
5689 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5692 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5695 v->sprite_output_frame = av_frame_alloc();
5696 if (!v->sprite_output_frame)
5697 return AVERROR(ENOMEM);
5699 avctx->profile = v->profile;
5700 if (v->profile == PROFILE_ADVANCED)
5701 avctx->level = v->level;
5703 avctx->has_b_frames = !!avctx->max_b_frames;
5705 s->mb_width = (avctx->coded_width + 15) >> 4;
5706 s->mb_height = (avctx->coded_height + 15) >> 4;
5708 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5709 ff_vc1_init_transposed_scantables(v);
5711 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5716 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5717 v->sprite_width = avctx->coded_width;
5718 v->sprite_height = avctx->coded_height;
5720 avctx->coded_width = avctx->width = v->output_width;
5721 avctx->coded_height = avctx->height = v->output_height;
5723 // prevent 16.16 overflows
5724 if (v->sprite_width > 1 << 14 ||
5725 v->sprite_height > 1 << 14 ||
5726 v->output_width > 1 << 14 ||
5727 v->output_height > 1 << 14) return -1;
5729 if ((v->sprite_width&1) || (v->sprite_height&1)) {
5730 avpriv_request_sample(avctx, "odd sprites support");
5731 return AVERROR_PATCHWELCOME;
5737 /** Close a VC1/WMV3 decoder
5738 * @warning Initial try at using MpegEncContext stuff
5740 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5742 VC1Context *v = avctx->priv_data;
5745 av_frame_free(&v->sprite_output_frame);
5747 for (i = 0; i < 4; i++)
5748 av_freep(&v->sr_rows[i >> 1][i & 1]);
5749 av_freep(&v->hrd_rate);
5750 av_freep(&v->hrd_buffer);
5751 ff_MPV_common_end(&v->s);
5752 av_freep(&v->mv_type_mb_plane);
5753 av_freep(&v->direct_mb_plane);
5754 av_freep(&v->forward_mb_plane);
5755 av_freep(&v->fieldtx_plane);
5756 av_freep(&v->acpred_plane);
5757 av_freep(&v->over_flags_plane);
5758 av_freep(&v->mb_type_base);
5759 av_freep(&v->blk_mv_type_base);
5760 av_freep(&v->mv_f_base);
5761 av_freep(&v->mv_f_next_base);
5762 av_freep(&v->block);
5763 av_freep(&v->cbp_base);
5764 av_freep(&v->ttblk_base);
5765 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5766 av_freep(&v->luma_mv_base);
5767 ff_intrax8_common_end(&v->x8);
5772 /** Decode a VC1/WMV3 frame
5773 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5775 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5776 int *got_frame, AVPacket *avpkt)
5778 const uint8_t *buf = avpkt->data;
5779 int buf_size = avpkt->size, n_slices = 0, i, ret;
5780 VC1Context *v = avctx->priv_data;
5781 MpegEncContext *s = &v->s;
5782 AVFrame *pict = data;
5783 uint8_t *buf2 = NULL;
5784 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
5785 int mb_height, n_slices1=-1;
5790 } *slices = NULL, *tmp;
5792 v->second_field = 0;
5794 if(s->flags & CODEC_FLAG_LOW_DELAY)
5797 /* no supplementary picture */
5798 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5799 /* special case for last picture */
5800 if (s->low_delay == 0 && s->next_picture_ptr) {
5801 if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
5803 s->next_picture_ptr = NULL;
5811 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5812 if (v->profile < PROFILE_ADVANCED)
5813 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5815 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5818 //for advanced profile we may need to parse and unescape data
5819 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5821 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5823 return AVERROR(ENOMEM);
5825 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5826 const uint8_t *start, *end, *next;
5830 for (start = buf, end = buf + buf_size; next < end; start = next) {
5831 next = find_next_marker(start + 4, end);
5832 size = next - start - 4;
5833 if (size <= 0) continue;
5834 switch (AV_RB32(start)) {
5835 case VC1_CODE_FRAME:
5836 if (avctx->hwaccel ||
5837 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5839 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5841 case VC1_CODE_FIELD: {
5843 if (avctx->hwaccel ||
5844 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5845 buf_start_second_field = start;
5846 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5850 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5851 if (!slices[n_slices].buf)
5853 buf_size3 = vc1_unescape_buffer(start + 4, size,
5854 slices[n_slices].buf);
5855 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5857 /* assuming that the field marker is at the exact middle,
5858 hope it's correct */
5859 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
5860 n_slices1 = n_slices - 1; // index of the last slice of the first field
5864 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5865 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5866 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5867 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5869 case VC1_CODE_SLICE: {
5871 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5875 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5876 if (!slices[n_slices].buf)
5878 buf_size3 = vc1_unescape_buffer(start + 4, size,
5879 slices[n_slices].buf);
5880 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5882 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5888 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5889 const uint8_t *divider;
5892 divider = find_next_marker(buf, buf + buf_size);
5893 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5894 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5896 } else { // found field marker, unescape second field
5897 if (avctx->hwaccel ||
5898 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5899 buf_start_second_field = divider;
5900 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5904 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5905 if (!slices[n_slices].buf)
5907 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5908 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5910 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
5911 n_slices1 = n_slices - 1;
5914 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5916 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5918 init_get_bits(&s->gb, buf2, buf_size2*8);
5920 init_get_bits(&s->gb, buf, buf_size*8);
5922 if (v->res_sprite) {
5923 v->new_sprite = !get_bits1(&s->gb);
5924 v->two_sprites = get_bits1(&s->gb);
5925 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5926 we're using the sprite compositor. These are intentionally kept separate
5927 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5928 the vc1 one for WVP2 */
5929 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5930 if (v->new_sprite) {
5931 // switch AVCodecContext parameters to those of the sprites
5932 avctx->width = avctx->coded_width = v->sprite_width;
5933 avctx->height = avctx->coded_height = v->sprite_height;
5940 if (s->context_initialized &&
5941 (s->width != avctx->coded_width ||
5942 s->height != avctx->coded_height)) {
5943 ff_vc1_decode_end(avctx);
5946 if (!s->context_initialized) {
5947 if (ff_msmpeg4_decode_init(avctx) < 0)
5949 if (ff_vc1_decode_init_alloc_tables(v) < 0) {
5950 ff_MPV_common_end(s);
5954 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5956 if (v->profile == PROFILE_ADVANCED) {
5957 if(avctx->coded_width<=1 || avctx->coded_height<=1)
5959 s->h_edge_pos = avctx->coded_width;
5960 s->v_edge_pos = avctx->coded_height;
5964 // do parse frame header
5965 v->pic_header_flag = 0;
5966 v->first_pic_header_flag = 1;
5967 if (v->profile < PROFILE_ADVANCED) {
5968 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5972 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5976 v->first_pic_header_flag = 0;
5978 if (avctx->debug & FF_DEBUG_PICT_INFO)
5979 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
5981 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5982 && s->pict_type != AV_PICTURE_TYPE_I) {
5983 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5987 if ((s->mb_height >> v->field_mode) == 0) {
5988 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
5992 // for skipping the frame
5993 s->current_picture.f.pict_type = s->pict_type;
5994 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5996 /* skip B-frames if we don't have reference frames */
5997 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
6000 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
6001 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
6002 avctx->skip_frame >= AVDISCARD_ALL) {
6006 if (s->next_p_frame_damaged) {
6007 if (s->pict_type == AV_PICTURE_TYPE_B)
6010 s->next_p_frame_damaged = 0;
6013 if (ff_MPV_frame_start(s, avctx) < 0) {
6017 v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
6018 v->s.current_picture_ptr->f.top_field_first = v->tff;
6020 // process pulldown flags
6021 s->current_picture_ptr->f.repeat_pict = 0;
6022 // Pulldown flags are only valid when 'broadcast' has been set.
6023 // So ticks_per_frame will be 2
6026 s->current_picture_ptr->f.repeat_pict = 1;
6027 } else if (v->rptfrm) {
6029 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
6032 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
6033 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
6035 if ((CONFIG_VC1_VDPAU_DECODER)
6036 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
6037 if (v->field_mode && buf_start_second_field) {
6038 ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
6039 ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
6041 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
6043 } else if (avctx->hwaccel) {
6044 if (v->field_mode && buf_start_second_field) {
6045 // decode first field
6046 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
6047 if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6049 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6051 if (avctx->hwaccel->end_frame(avctx) < 0)
6054 // decode second field
6055 s->gb = slices[n_slices1 + 1].gb;
6056 s->picture_structure = PICT_TOP_FIELD + v->tff;
6057 v->second_field = 1;
6058 v->pic_header_flag = 0;
6059 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
6060 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
6063 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
6065 if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6067 if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6069 if (avctx->hwaccel->end_frame(avctx) < 0)
6072 s->picture_structure = PICT_FRAME;
6073 if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6075 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6077 if (avctx->hwaccel->end_frame(avctx) < 0)
6083 ff_mpeg_er_frame_start(s);
6085 v->bits = buf_size * 8;
6086 v->end_mb_x = s->mb_width;
6087 if (v->field_mode) {
6088 s->current_picture.f.linesize[0] <<= 1;
6089 s->current_picture.f.linesize[1] <<= 1;
6090 s->current_picture.f.linesize[2] <<= 1;
6092 s->uvlinesize <<= 1;
6094 mb_height = s->mb_height >> v->field_mode;
6096 av_assert0 (mb_height > 0);
6098 for (i = 0; i <= n_slices; i++) {
6099 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
6100 if (v->field_mode <= 0) {
6101 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
6102 "picture boundary (%d >= %d)\n", i,
6103 slices[i - 1].mby_start, mb_height);
6106 v->second_field = 1;
6107 av_assert0((s->mb_height & 1) == 0);
6108 v->blocks_off = s->b8_stride * (s->mb_height&~1);
6109 v->mb_off = s->mb_stride * s->mb_height >> 1;
6111 v->second_field = 0;
6116 v->pic_header_flag = 0;
6117 if (v->field_mode && i == n_slices1 + 2) {
6118 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6119 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
6120 if (avctx->err_recognition & AV_EF_EXPLODE)
6124 } else if (get_bits1(&s->gb)) {
6125 v->pic_header_flag = 1;
6126 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6127 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
6128 if (avctx->err_recognition & AV_EF_EXPLODE)
6136 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
6137 if (!v->field_mode || v->second_field)
6138 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6140 if (i >= n_slices) {
6141 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
6144 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6146 if (s->end_mb_y <= s->start_mb_y) {
6147 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
6150 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
6151 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
6154 ff_vc1_decode_blocks(v);
6156 s->gb = slices[i].gb;
6158 if (v->field_mode) {
6159 v->second_field = 0;
6160 s->current_picture.f.linesize[0] >>= 1;
6161 s->current_picture.f.linesize[1] >>= 1;
6162 s->current_picture.f.linesize[2] >>= 1;
6164 s->uvlinesize >>= 1;
6165 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
6166 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
6167 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
6170 av_dlog(s->avctx, "Consumed %i/%i bits\n",
6171 get_bits_count(&s->gb), s->gb.size_in_bits);
6172 // if (get_bits_count(&s->gb) > buf_size * 8)
6174 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
6177 ff_er_frame_end(&s->er);
6180 ff_MPV_frame_end(s);
6182 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
6184 avctx->width = avctx->coded_width = v->output_width;
6185 avctx->height = avctx->coded_height = v->output_height;
6186 if (avctx->skip_frame >= AVDISCARD_NONREF)
6188 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
6189 if (vc1_decode_sprites(v, &s->gb))
6192 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
6196 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
6197 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
6199 ff_print_debug_info(s, s->current_picture_ptr, pict);
6201 } else if (s->last_picture_ptr != NULL) {
6202 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
6204 ff_print_debug_info(s, s->last_picture_ptr, pict);
6211 for (i = 0; i < n_slices; i++)
6212 av_free(slices[i].buf);
6218 for (i = 0; i < n_slices; i++)
6219 av_free(slices[i].buf);
6225 static const AVProfile profiles[] = {
6226 { FF_PROFILE_VC1_SIMPLE, "Simple" },
6227 { FF_PROFILE_VC1_MAIN, "Main" },
6228 { FF_PROFILE_VC1_COMPLEX, "Complex" },
6229 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
6230 { FF_PROFILE_UNKNOWN },
6233 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
6235 AV_PIX_FMT_DXVA2_VLD,
6238 AV_PIX_FMT_VAAPI_VLD,
6247 AVCodec ff_vc1_decoder = {
6249 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
6250 .type = AVMEDIA_TYPE_VIDEO,
6251 .id = AV_CODEC_ID_VC1,
6252 .priv_data_size = sizeof(VC1Context),
6253 .init = vc1_decode_init,
6254 .close = ff_vc1_decode_end,
6255 .decode = vc1_decode_frame,
6256 .flush = ff_mpeg_flush,
6257 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6258 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6259 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6262 #if CONFIG_WMV3_DECODER
6263 AVCodec ff_wmv3_decoder = {
6265 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
6266 .type = AVMEDIA_TYPE_VIDEO,
6267 .id = AV_CODEC_ID_WMV3,
6268 .priv_data_size = sizeof(VC1Context),
6269 .init = vc1_decode_init,
6270 .close = ff_vc1_decode_end,
6271 .decode = vc1_decode_frame,
6272 .flush = ff_mpeg_flush,
6273 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6274 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6275 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6279 #if CONFIG_WMV3_VDPAU_DECODER
6280 AVCodec ff_wmv3_vdpau_decoder = {
6281 .name = "wmv3_vdpau",
6282 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
6283 .type = AVMEDIA_TYPE_VIDEO,
6284 .id = AV_CODEC_ID_WMV3,
6285 .priv_data_size = sizeof(VC1Context),
6286 .init = vc1_decode_init,
6287 .close = ff_vc1_decode_end,
6288 .decode = vc1_decode_frame,
6289 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6290 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
6291 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6295 #if CONFIG_VC1_VDPAU_DECODER
6296 AVCodec ff_vc1_vdpau_decoder = {
6297 .name = "vc1_vdpau",
6298 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
6299 .type = AVMEDIA_TYPE_VIDEO,
6300 .id = AV_CODEC_ID_VC1,
6301 .priv_data_size = sizeof(VC1Context),
6302 .init = vc1_decode_init,
6303 .close = ff_vc1_decode_end,
6304 .decode = vc1_decode_frame,
6305 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6306 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
6307 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6311 #if CONFIG_WMV3IMAGE_DECODER
6312 AVCodec ff_wmv3image_decoder = {
6313 .name = "wmv3image",
6314 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
6315 .type = AVMEDIA_TYPE_VIDEO,
6316 .id = AV_CODEC_ID_WMV3IMAGE,
6317 .priv_data_size = sizeof(VC1Context),
6318 .init = vc1_decode_init,
6319 .close = ff_vc1_decode_end,
6320 .decode = vc1_decode_frame,
6321 .capabilities = CODEC_CAP_DR1,
6322 .flush = vc1_sprite_flush,
6323 .pix_fmts = ff_pixfmt_list_420
6327 #if CONFIG_VC1IMAGE_DECODER
6328 AVCodec ff_vc1image_decoder = {
6330 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
6331 .type = AVMEDIA_TYPE_VIDEO,
6332 .id = AV_CODEC_ID_VC1IMAGE,
6333 .priv_data_size = sizeof(VC1Context),
6334 .init = vc1_decode_init,
6335 .close = ff_vc1_decode_end,
6336 .decode = vc1_decode_frame,
6337 .capabilities = CODEC_CAP_DR1,
6338 .flush = vc1_sprite_flush,
6339 .pix_fmts = ff_pixfmt_list_420