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];
2116 av_assert0(!v->field_mode);
2120 /* scale MV difference to be quad-pel */
2121 dmv_x[0] <<= 1 - s->quarter_sample;
2122 dmv_y[0] <<= 1 - s->quarter_sample;
2123 dmv_x[1] <<= 1 - s->quarter_sample;
2124 dmv_y[1] <<= 1 - s->quarter_sample;
2126 wrap = s->b8_stride;
2127 xy = s->block_index[0];
2130 s->current_picture.motion_val[0][xy][0] =
2131 s->current_picture.motion_val[0][xy][1] =
2132 s->current_picture.motion_val[1][xy][0] =
2133 s->current_picture.motion_val[1][xy][1] = 0;
2136 if (direct && s->next_picture_ptr->field_picture)
2137 av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
2139 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2140 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2141 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2142 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2144 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2145 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));
2146 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));
2147 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));
2148 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));
2150 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2151 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2152 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2153 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2157 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2158 C = s->current_picture.motion_val[0][xy - 2];
2159 A = s->current_picture.motion_val[0][xy - wrap * 2];
2160 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2161 B = s->current_picture.motion_val[0][xy - wrap * 2 + off];
2163 if (!s->mb_x) C[0] = C[1] = 0;
2164 if (!s->first_slice_line) { // predictor A is not out of bounds
2165 if (s->mb_width == 1) {
2169 px = mid_pred(A[0], B[0], C[0]);
2170 py = mid_pred(A[1], B[1], C[1]);
2172 } else if (s->mb_x) { // predictor C is not out of bounds
2178 /* Pullback MV as specified in 8.3.5.3.4 */
2181 if (v->profile < PROFILE_ADVANCED) {
2182 qx = (s->mb_x << 5);
2183 qy = (s->mb_y << 5);
2184 X = (s->mb_width << 5) - 4;
2185 Y = (s->mb_height << 5) - 4;
2186 if (qx + px < -28) px = -28 - qx;
2187 if (qy + py < -28) py = -28 - qy;
2188 if (qx + px > X) px = X - qx;
2189 if (qy + py > Y) py = Y - qy;
2191 qx = (s->mb_x << 6);
2192 qy = (s->mb_y << 6);
2193 X = (s->mb_width << 6) - 4;
2194 Y = (s->mb_height << 6) - 4;
2195 if (qx + px < -60) px = -60 - qx;
2196 if (qy + py < -60) py = -60 - qy;
2197 if (qx + px > X) px = X - qx;
2198 if (qy + py > Y) py = Y - qy;
2201 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2202 if (0 && !s->first_slice_line && s->mb_x) {
2203 if (is_intra[xy - wrap])
2204 sum = FFABS(px) + FFABS(py);
2206 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2208 if (get_bits1(&s->gb)) {
2216 if (is_intra[xy - 2])
2217 sum = FFABS(px) + FFABS(py);
2219 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2221 if (get_bits1(&s->gb)) {
2231 /* store MV using signed modulus of MV range defined in 4.11 */
2232 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2233 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2235 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2236 C = s->current_picture.motion_val[1][xy - 2];
2237 A = s->current_picture.motion_val[1][xy - wrap * 2];
2238 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2239 B = s->current_picture.motion_val[1][xy - wrap * 2 + off];
2243 if (!s->first_slice_line) { // predictor A is not out of bounds
2244 if (s->mb_width == 1) {
2248 px = mid_pred(A[0], B[0], C[0]);
2249 py = mid_pred(A[1], B[1], C[1]);
2251 } else if (s->mb_x) { // predictor C is not out of bounds
2257 /* Pullback MV as specified in 8.3.5.3.4 */
2260 if (v->profile < PROFILE_ADVANCED) {
2261 qx = (s->mb_x << 5);
2262 qy = (s->mb_y << 5);
2263 X = (s->mb_width << 5) - 4;
2264 Y = (s->mb_height << 5) - 4;
2265 if (qx + px < -28) px = -28 - qx;
2266 if (qy + py < -28) py = -28 - qy;
2267 if (qx + px > X) px = X - qx;
2268 if (qy + py > Y) py = Y - qy;
2270 qx = (s->mb_x << 6);
2271 qy = (s->mb_y << 6);
2272 X = (s->mb_width << 6) - 4;
2273 Y = (s->mb_height << 6) - 4;
2274 if (qx + px < -60) px = -60 - qx;
2275 if (qy + py < -60) py = -60 - qy;
2276 if (qx + px > X) px = X - qx;
2277 if (qy + py > Y) py = Y - qy;
2280 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2281 if (0 && !s->first_slice_line && s->mb_x) {
2282 if (is_intra[xy - wrap])
2283 sum = FFABS(px) + FFABS(py);
2285 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2287 if (get_bits1(&s->gb)) {
2295 if (is_intra[xy - 2])
2296 sum = FFABS(px) + FFABS(py);
2298 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2300 if (get_bits1(&s->gb)) {
2310 /* store MV using signed modulus of MV range defined in 4.11 */
2312 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2313 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2315 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2316 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2317 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2318 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2321 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2323 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2324 MpegEncContext *s = &v->s;
2325 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2327 if (v->bmvtype == BMV_TYPE_DIRECT) {
2328 int total_opp, k, f;
2329 if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2330 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2331 v->bfraction, 0, s->quarter_sample);
2332 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2333 v->bfraction, 0, s->quarter_sample);
2334 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2335 v->bfraction, 1, s->quarter_sample);
2336 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2337 v->bfraction, 1, s->quarter_sample);
2339 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2340 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2341 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2342 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2343 f = (total_opp > 2) ? 1 : 0;
2345 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2346 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2349 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2350 for (k = 0; k < 4; k++) {
2351 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2352 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2353 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2354 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2355 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2356 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2360 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2361 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);
2362 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);
2365 if (dir) { // backward
2366 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);
2367 if (n == 3 || mv1) {
2368 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2371 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);
2372 if (n == 3 || mv1) {
2373 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2378 /** Get predicted DC value for I-frames only
2379 * prediction dir: left=0, top=1
2380 * @param s MpegEncContext
2381 * @param overlap flag indicating that overlap filtering is used
2382 * @param pq integer part of picture quantizer
2383 * @param[in] n block index in the current MB
2384 * @param dc_val_ptr Pointer to DC predictor
2385 * @param dir_ptr Prediction direction for use in AC prediction
2387 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2388 int16_t **dc_val_ptr, int *dir_ptr)
2390 int a, b, c, wrap, pred, scale;
2392 static const uint16_t dcpred[32] = {
2393 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2394 114, 102, 93, 85, 79, 73, 68, 64,
2395 60, 57, 54, 51, 49, 47, 45, 43,
2396 41, 39, 38, 37, 35, 34, 33
2399 /* find prediction - wmv3_dc_scale always used here in fact */
2400 if (n < 4) scale = s->y_dc_scale;
2401 else scale = s->c_dc_scale;
2403 wrap = s->block_wrap[n];
2404 dc_val = s->dc_val[0] + s->block_index[n];
2410 b = dc_val[ - 1 - wrap];
2411 a = dc_val[ - wrap];
2413 if (pq < 9 || !overlap) {
2414 /* Set outer values */
2415 if (s->first_slice_line && (n != 2 && n != 3))
2416 b = a = dcpred[scale];
2417 if (s->mb_x == 0 && (n != 1 && n != 3))
2418 b = c = dcpred[scale];
2420 /* Set outer values */
2421 if (s->first_slice_line && (n != 2 && n != 3))
2423 if (s->mb_x == 0 && (n != 1 && n != 3))
2427 if (abs(a - b) <= abs(b - c)) {
2429 *dir_ptr = 1; // left
2432 *dir_ptr = 0; // top
2435 /* update predictor */
2436 *dc_val_ptr = &dc_val[0];
2441 /** Get predicted DC value
2442 * prediction dir: left=0, top=1
2443 * @param s MpegEncContext
2444 * @param overlap flag indicating that overlap filtering is used
2445 * @param pq integer part of picture quantizer
2446 * @param[in] n block index in the current MB
2447 * @param a_avail flag indicating top block availability
2448 * @param c_avail flag indicating left block availability
2449 * @param dc_val_ptr Pointer to DC predictor
2450 * @param dir_ptr Prediction direction for use in AC prediction
2452 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2453 int a_avail, int c_avail,
2454 int16_t **dc_val_ptr, int *dir_ptr)
2456 int a, b, c, wrap, pred;
2458 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2462 wrap = s->block_wrap[n];
2463 dc_val = s->dc_val[0] + s->block_index[n];
2469 b = dc_val[ - 1 - wrap];
2470 a = dc_val[ - wrap];
2471 /* scale predictors if needed */
2472 q1 = s->current_picture.qscale_table[mb_pos];
2473 dqscale_index = s->y_dc_scale_table[q1] - 1;
2474 if (dqscale_index < 0)
2476 if (c_avail && (n != 1 && n != 3)) {
2477 q2 = s->current_picture.qscale_table[mb_pos - 1];
2479 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2481 if (a_avail && (n != 2 && n != 3)) {
2482 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2484 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2486 if (a_avail && c_avail && (n != 3)) {
2491 off -= s->mb_stride;
2492 q2 = s->current_picture.qscale_table[off];
2494 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2497 if (a_avail && c_avail) {
2498 if (abs(a - b) <= abs(b - c)) {
2500 *dir_ptr = 1; // left
2503 *dir_ptr = 0; // top
2505 } else if (a_avail) {
2507 *dir_ptr = 0; // top
2508 } else if (c_avail) {
2510 *dir_ptr = 1; // left
2513 *dir_ptr = 1; // left
2516 /* update predictor */
2517 *dc_val_ptr = &dc_val[0];
2521 /** @} */ // Block group
2524 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2525 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2529 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2530 uint8_t **coded_block_ptr)
2532 int xy, wrap, pred, a, b, c;
2534 xy = s->block_index[n];
2535 wrap = s->b8_stride;
2540 a = s->coded_block[xy - 1 ];
2541 b = s->coded_block[xy - 1 - wrap];
2542 c = s->coded_block[xy - wrap];
2551 *coded_block_ptr = &s->coded_block[xy];
2557 * Decode one AC coefficient
2558 * @param v The VC1 context
2559 * @param last Last coefficient
2560 * @param skip How much zero coefficients to skip
2561 * @param value Decoded AC coefficient value
2562 * @param codingset set of VLC to decode data
2565 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2566 int *value, int codingset)
2568 GetBitContext *gb = &v->s.gb;
2569 int index, escape, run = 0, level = 0, lst = 0;
2571 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2572 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2573 run = vc1_index_decode_table[codingset][index][0];
2574 level = vc1_index_decode_table[codingset][index][1];
2575 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2579 escape = decode210(gb);
2581 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2582 run = vc1_index_decode_table[codingset][index][0];
2583 level = vc1_index_decode_table[codingset][index][1];
2584 lst = index >= vc1_last_decode_table[codingset];
2587 level += vc1_last_delta_level_table[codingset][run];
2589 level += vc1_delta_level_table[codingset][run];
2592 run += vc1_last_delta_run_table[codingset][level] + 1;
2594 run += vc1_delta_run_table[codingset][level] + 1;
2600 lst = get_bits1(gb);
2601 if (v->s.esc3_level_length == 0) {
2602 if (v->pq < 8 || v->dquantfrm) { // table 59
2603 v->s.esc3_level_length = get_bits(gb, 3);
2604 if (!v->s.esc3_level_length)
2605 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2606 } else { // table 60
2607 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2609 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2611 run = get_bits(gb, v->s.esc3_run_length);
2612 sign = get_bits1(gb);
2613 level = get_bits(gb, v->s.esc3_level_length);
2624 /** Decode intra block in intra frames - should be faster than decode_intra_block
2625 * @param v VC1Context
2626 * @param block block to decode
2627 * @param[in] n subblock index
2628 * @param coded are AC coeffs present or not
2629 * @param codingset set of VLC to decode data
2631 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
2632 int coded, int codingset)
2634 GetBitContext *gb = &v->s.gb;
2635 MpegEncContext *s = &v->s;
2636 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2639 int16_t *ac_val, *ac_val2;
2642 /* Get DC differential */
2644 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2646 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2649 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2653 if (dcdiff == 119 /* ESC index value */) {
2654 /* TODO: Optimize */
2655 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2656 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2657 else dcdiff = get_bits(gb, 8);
2660 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2661 else if (v->pq == 2)
2662 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2669 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2672 /* Store the quantized DC coeff, used for prediction */
2674 block[0] = dcdiff * s->y_dc_scale;
2676 block[0] = dcdiff * s->c_dc_scale;
2687 int last = 0, skip, value;
2688 const uint8_t *zz_table;
2692 scale = v->pq * 2 + v->halfpq;
2696 zz_table = v->zz_8x8[2];
2698 zz_table = v->zz_8x8[3];
2700 zz_table = v->zz_8x8[1];
2702 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2704 if (dc_pred_dir) // left
2707 ac_val -= 16 * s->block_wrap[n];
2710 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2714 block[zz_table[i++]] = value;
2717 /* apply AC prediction if needed */
2719 if (dc_pred_dir) { // left
2720 for (k = 1; k < 8; k++)
2721 block[k << v->left_blk_sh] += ac_val[k];
2723 for (k = 1; k < 8; k++)
2724 block[k << v->top_blk_sh] += ac_val[k + 8];
2727 /* save AC coeffs for further prediction */
2728 for (k = 1; k < 8; k++) {
2729 ac_val2[k] = block[k << v->left_blk_sh];
2730 ac_val2[k + 8] = block[k << v->top_blk_sh];
2733 /* scale AC coeffs */
2734 for (k = 1; k < 64; k++)
2738 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2741 if (s->ac_pred) i = 63;
2747 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2751 scale = v->pq * 2 + v->halfpq;
2752 memset(ac_val2, 0, 16 * 2);
2753 if (dc_pred_dir) { // left
2756 memcpy(ac_val2, ac_val, 8 * 2);
2758 ac_val -= 16 * s->block_wrap[n];
2760 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2763 /* apply AC prediction if needed */
2765 if (dc_pred_dir) { //left
2766 for (k = 1; k < 8; k++) {
2767 block[k << v->left_blk_sh] = ac_val[k] * scale;
2768 if (!v->pquantizer && block[k << v->left_blk_sh])
2769 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2772 for (k = 1; k < 8; k++) {
2773 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2774 if (!v->pquantizer && block[k << v->top_blk_sh])
2775 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2781 s->block_last_index[n] = i;
2786 /** Decode intra block in intra frames - should be faster than decode_intra_block
2787 * @param v VC1Context
2788 * @param block block to decode
2789 * @param[in] n subblock number
2790 * @param coded are AC coeffs present or not
2791 * @param codingset set of VLC to decode data
2792 * @param mquant quantizer value for this macroblock
2794 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
2795 int coded, int codingset, int mquant)
2797 GetBitContext *gb = &v->s.gb;
2798 MpegEncContext *s = &v->s;
2799 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2801 int16_t *dc_val = NULL;
2802 int16_t *ac_val, *ac_val2;
2804 int a_avail = v->a_avail, c_avail = v->c_avail;
2805 int use_pred = s->ac_pred;
2808 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2810 /* Get DC differential */
2812 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2814 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2817 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2821 if (dcdiff == 119 /* ESC index value */) {
2822 /* TODO: Optimize */
2823 if (mquant == 1) dcdiff = get_bits(gb, 10);
2824 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2825 else dcdiff = get_bits(gb, 8);
2828 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2829 else if (mquant == 2)
2830 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2837 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2840 /* Store the quantized DC coeff, used for prediction */
2842 block[0] = dcdiff * s->y_dc_scale;
2844 block[0] = dcdiff * s->c_dc_scale;
2850 /* check if AC is needed at all */
2851 if (!a_avail && !c_avail)
2853 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2856 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2858 if (dc_pred_dir) // left
2861 ac_val -= 16 * s->block_wrap[n];
2863 q1 = s->current_picture.qscale_table[mb_pos];
2864 if ( dc_pred_dir && c_avail && mb_pos)
2865 q2 = s->current_picture.qscale_table[mb_pos - 1];
2866 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2867 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2868 if ( dc_pred_dir && n == 1)
2870 if (!dc_pred_dir && n == 2)
2876 int last = 0, skip, value;
2877 const uint8_t *zz_table;
2881 if (!use_pred && v->fcm == ILACE_FRAME) {
2882 zz_table = v->zzi_8x8;
2884 if (!dc_pred_dir) // top
2885 zz_table = v->zz_8x8[2];
2887 zz_table = v->zz_8x8[3];
2890 if (v->fcm != ILACE_FRAME)
2891 zz_table = v->zz_8x8[1];
2893 zz_table = v->zzi_8x8;
2897 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2901 block[zz_table[i++]] = value;
2904 /* apply AC prediction if needed */
2906 /* scale predictors if needed*/
2907 if (q2 && q1 != q2) {
2908 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2909 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2912 return AVERROR_INVALIDDATA;
2913 if (dc_pred_dir) { // left
2914 for (k = 1; k < 8; k++)
2915 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2917 for (k = 1; k < 8; k++)
2918 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2921 if (dc_pred_dir) { //left
2922 for (k = 1; k < 8; k++)
2923 block[k << v->left_blk_sh] += ac_val[k];
2925 for (k = 1; k < 8; k++)
2926 block[k << v->top_blk_sh] += ac_val[k + 8];
2930 /* save AC coeffs for further prediction */
2931 for (k = 1; k < 8; k++) {
2932 ac_val2[k ] = block[k << v->left_blk_sh];
2933 ac_val2[k + 8] = block[k << v->top_blk_sh];
2936 /* scale AC coeffs */
2937 for (k = 1; k < 64; k++)
2941 block[k] += (block[k] < 0) ? -mquant : mquant;
2944 if (use_pred) i = 63;
2945 } else { // no AC coeffs
2948 memset(ac_val2, 0, 16 * 2);
2949 if (dc_pred_dir) { // left
2951 memcpy(ac_val2, ac_val, 8 * 2);
2952 if (q2 && q1 != q2) {
2953 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2954 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2956 return AVERROR_INVALIDDATA;
2957 for (k = 1; k < 8; k++)
2958 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2963 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2964 if (q2 && q1 != q2) {
2965 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2966 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2968 return AVERROR_INVALIDDATA;
2969 for (k = 1; k < 8; k++)
2970 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2975 /* apply AC prediction if needed */
2977 if (dc_pred_dir) { // left
2978 for (k = 1; k < 8; k++) {
2979 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2980 if (!v->pquantizer && block[k << v->left_blk_sh])
2981 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2984 for (k = 1; k < 8; k++) {
2985 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2986 if (!v->pquantizer && block[k << v->top_blk_sh])
2987 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2993 s->block_last_index[n] = i;
2998 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2999 * @param v VC1Context
3000 * @param block block to decode
3001 * @param[in] n subblock index
3002 * @param coded are AC coeffs present or not
3003 * @param mquant block quantizer
3004 * @param codingset set of VLC to decode data
3006 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
3007 int coded, int mquant, int codingset)
3009 GetBitContext *gb = &v->s.gb;
3010 MpegEncContext *s = &v->s;
3011 int dc_pred_dir = 0; /* Direction of the DC prediction used */
3013 int16_t *dc_val = NULL;
3014 int16_t *ac_val, *ac_val2;
3016 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3017 int a_avail = v->a_avail, c_avail = v->c_avail;
3018 int use_pred = s->ac_pred;
3022 s->dsp.clear_block(block);
3024 /* XXX: Guard against dumb values of mquant */
3025 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
3027 /* Set DC scale - y and c use the same */
3028 s->y_dc_scale = s->y_dc_scale_table[mquant];
3029 s->c_dc_scale = s->c_dc_scale_table[mquant];
3031 /* Get DC differential */
3033 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3035 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3038 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3042 if (dcdiff == 119 /* ESC index value */) {
3043 /* TODO: Optimize */
3044 if (mquant == 1) dcdiff = get_bits(gb, 10);
3045 else if (mquant == 2) dcdiff = get_bits(gb, 9);
3046 else dcdiff = get_bits(gb, 8);
3049 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
3050 else if (mquant == 2)
3051 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
3058 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3061 /* Store the quantized DC coeff, used for prediction */
3064 block[0] = dcdiff * s->y_dc_scale;
3066 block[0] = dcdiff * s->c_dc_scale;
3072 /* check if AC is needed at all and adjust direction if needed */
3073 if (!a_avail) dc_pred_dir = 1;
3074 if (!c_avail) dc_pred_dir = 0;
3075 if (!a_avail && !c_avail) use_pred = 0;
3076 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3079 scale = mquant * 2 + v->halfpq;
3081 if (dc_pred_dir) //left
3084 ac_val -= 16 * s->block_wrap[n];
3086 q1 = s->current_picture.qscale_table[mb_pos];
3087 if (dc_pred_dir && c_avail && mb_pos)
3088 q2 = s->current_picture.qscale_table[mb_pos - 1];
3089 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3090 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3091 if ( dc_pred_dir && n == 1)
3093 if (!dc_pred_dir && n == 2)
3095 if (n == 3) q2 = q1;
3098 int last = 0, skip, value;
3102 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3106 if (v->fcm == PROGRESSIVE)
3107 block[v->zz_8x8[0][i++]] = value;
3109 if (use_pred && (v->fcm == ILACE_FRAME)) {
3110 if (!dc_pred_dir) // top
3111 block[v->zz_8x8[2][i++]] = value;
3113 block[v->zz_8x8[3][i++]] = value;
3115 block[v->zzi_8x8[i++]] = value;
3120 /* apply AC prediction if needed */
3122 /* scale predictors if needed*/
3123 if (q2 && q1 != q2) {
3124 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3125 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3128 return AVERROR_INVALIDDATA;
3129 if (dc_pred_dir) { // left
3130 for (k = 1; k < 8; k++)
3131 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3133 for (k = 1; k < 8; k++)
3134 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3137 if (dc_pred_dir) { // left
3138 for (k = 1; k < 8; k++)
3139 block[k << v->left_blk_sh] += ac_val[k];
3141 for (k = 1; k < 8; k++)
3142 block[k << v->top_blk_sh] += ac_val[k + 8];
3146 /* save AC coeffs for further prediction */
3147 for (k = 1; k < 8; k++) {
3148 ac_val2[k ] = block[k << v->left_blk_sh];
3149 ac_val2[k + 8] = block[k << v->top_blk_sh];
3152 /* scale AC coeffs */
3153 for (k = 1; k < 64; k++)
3157 block[k] += (block[k] < 0) ? -mquant : mquant;
3160 if (use_pred) i = 63;
3161 } else { // no AC coeffs
3164 memset(ac_val2, 0, 16 * 2);
3165 if (dc_pred_dir) { // left
3167 memcpy(ac_val2, ac_val, 8 * 2);
3168 if (q2 && q1 != q2) {
3169 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3170 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3172 return AVERROR_INVALIDDATA;
3173 for (k = 1; k < 8; k++)
3174 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3179 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3180 if (q2 && q1 != q2) {
3181 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3182 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3184 return AVERROR_INVALIDDATA;
3185 for (k = 1; k < 8; k++)
3186 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3191 /* apply AC prediction if needed */
3193 if (dc_pred_dir) { // left
3194 for (k = 1; k < 8; k++) {
3195 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3196 if (!v->pquantizer && block[k << v->left_blk_sh])
3197 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3200 for (k = 1; k < 8; k++) {
3201 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3202 if (!v->pquantizer && block[k << v->top_blk_sh])
3203 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3209 s->block_last_index[n] = i;
3216 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
3217 int mquant, int ttmb, int first_block,
3218 uint8_t *dst, int linesize, int skip_block,
3221 MpegEncContext *s = &v->s;
3222 GetBitContext *gb = &s->gb;
3225 int scale, off, idx, last, skip, value;
3226 int ttblk = ttmb & 7;
3229 s->dsp.clear_block(block);
3232 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)];
3234 if (ttblk == TT_4X4) {
3235 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3237 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3238 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3239 || (!v->res_rtm_flag && !first_block))) {
3240 subblkpat = decode012(gb);
3242 subblkpat ^= 3; // swap decoded pattern bits
3243 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3245 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3248 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3250 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3251 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3252 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3255 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3256 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3265 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3270 idx = v->zz_8x8[0][i++];
3272 idx = v->zzi_8x8[i++];
3273 block[idx] = value * scale;
3275 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3279 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3281 v->vc1dsp.vc1_inv_trans_8x8(block);
3282 s->dsp.add_pixels_clamped(block, dst, linesize);
3287 pat = ~subblkpat & 0xF;
3288 for (j = 0; j < 4; j++) {
3289 last = subblkpat & (1 << (3 - j));
3291 off = (j & 1) * 4 + (j & 2) * 16;
3293 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3298 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3300 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3301 block[idx + off] = value * scale;
3303 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3305 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3307 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3309 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3314 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3315 for (j = 0; j < 2; j++) {
3316 last = subblkpat & (1 << (1 - j));
3320 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3325 idx = v->zz_8x4[i++] + off;
3327 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3328 block[idx] = value * scale;
3330 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3332 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3334 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3336 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3341 pat = ~(subblkpat * 5) & 0xF;
3342 for (j = 0; j < 2; j++) {
3343 last = subblkpat & (1 << (1 - j));
3347 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3352 idx = v->zz_4x8[i++] + off;
3354 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3355 block[idx] = value * scale;
3357 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3359 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3361 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3363 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3369 *ttmb_out |= ttblk << (n * 4);
3373 /** @} */ // Macroblock group
3375 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3376 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3378 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3380 MpegEncContext *s = &v->s;
3381 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3382 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3383 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3384 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3385 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3388 if (block_num > 3) {
3389 dst = s->dest[block_num - 3];
3391 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3393 if (s->mb_y != s->end_mb_y || block_num < 2) {
3397 if (block_num > 3) {
3398 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3399 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3400 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3401 mv_stride = s->mb_stride;
3403 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3404 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3405 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3406 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3407 mv_stride = s->b8_stride;
3408 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3411 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3412 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3413 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3415 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3417 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3420 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3422 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3427 dst -= 4 * linesize;
3428 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3429 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3430 idx = (block_cbp | (block_cbp >> 2)) & 3;
3432 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3435 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3437 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3442 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3444 MpegEncContext *s = &v->s;
3445 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3446 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3447 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3448 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3449 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3452 if (block_num > 3) {
3453 dst = s->dest[block_num - 3] - 8 * linesize;
3455 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3458 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3461 if (block_num > 3) {
3462 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3463 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3464 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3466 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3467 : (mb_cbp >> ((block_num + 1) * 4));
3468 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3469 : (mb_is_intra >> ((block_num + 1) * 4));
3470 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3472 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3473 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3475 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3477 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3480 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3482 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3488 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3489 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3490 idx = (block_cbp | (block_cbp >> 1)) & 5;
3492 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3495 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3497 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3502 static void vc1_apply_p_loop_filter(VC1Context *v)
3504 MpegEncContext *s = &v->s;
3507 for (i = 0; i < 6; i++) {
3508 vc1_apply_p_v_loop_filter(v, i);
3511 /* V always precedes H, therefore we run H one MB before V;
3512 * at the end of a row, we catch up to complete the row */
3514 for (i = 0; i < 6; i++) {
3515 vc1_apply_p_h_loop_filter(v, i);
3517 if (s->mb_x == s->mb_width - 1) {
3519 ff_update_block_index(s);
3520 for (i = 0; i < 6; i++) {
3521 vc1_apply_p_h_loop_filter(v, i);
3527 /** Decode one P-frame MB
3529 static int vc1_decode_p_mb(VC1Context *v)
3531 MpegEncContext *s = &v->s;
3532 GetBitContext *gb = &s->gb;
3534 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3535 int cbp; /* cbp decoding stuff */
3536 int mqdiff, mquant; /* MB quantization */
3537 int ttmb = v->ttfrm; /* MB Transform type */
3539 int mb_has_coeffs = 1; /* last_flag */
3540 int dmv_x, dmv_y; /* Differential MV components */
3541 int index, index1; /* LUT indexes */
3542 int val, sign; /* temp values */
3543 int first_block = 1;
3545 int skipped, fourmv;
3546 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3548 mquant = v->pq; /* lossy initialization */
3550 if (v->mv_type_is_raw)
3551 fourmv = get_bits1(gb);
3553 fourmv = v->mv_type_mb_plane[mb_pos];
3555 skipped = get_bits1(gb);
3557 skipped = v->s.mbskip_table[mb_pos];
3559 if (!fourmv) { /* 1MV mode */
3561 GET_MVDATA(dmv_x, dmv_y);
3564 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3565 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3567 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3568 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3570 /* FIXME Set DC val for inter block ? */
3571 if (s->mb_intra && !mb_has_coeffs) {
3573 s->ac_pred = get_bits1(gb);
3575 } else if (mb_has_coeffs) {
3577 s->ac_pred = get_bits1(gb);
3578 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3584 s->current_picture.qscale_table[mb_pos] = mquant;
3586 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3587 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3588 VC1_TTMB_VLC_BITS, 2);
3589 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3591 for (i = 0; i < 6; i++) {
3592 s->dc_val[0][s->block_index[i]] = 0;
3594 val = ((cbp >> (5 - i)) & 1);
3595 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3596 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3598 /* check if prediction blocks A and C are available */
3599 v->a_avail = v->c_avail = 0;
3600 if (i == 2 || i == 3 || !s->first_slice_line)
3601 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3602 if (i == 1 || i == 3 || s->mb_x)
3603 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3605 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3606 (i & 4) ? v->codingset2 : v->codingset);
3607 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3609 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3611 for (j = 0; j < 64; j++)
3612 s->block[i][j] <<= 1;
3613 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3614 if (v->pq >= 9 && v->overlap) {
3616 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3618 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3620 block_cbp |= 0xF << (i << 2);
3621 block_intra |= 1 << i;
3623 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3624 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3625 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3626 block_cbp |= pat << (i << 2);
3627 if (!v->ttmbf && ttmb < 8)
3634 for (i = 0; i < 6; i++) {
3635 v->mb_type[0][s->block_index[i]] = 0;
3636 s->dc_val[0][s->block_index[i]] = 0;
3638 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3639 s->current_picture.qscale_table[mb_pos] = 0;
3640 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3643 } else { // 4MV mode
3644 if (!skipped /* unskipped MB */) {
3645 int intra_count = 0, coded_inter = 0;
3646 int is_intra[6], is_coded[6];
3648 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3649 for (i = 0; i < 6; i++) {
3650 val = ((cbp >> (5 - i)) & 1);
3651 s->dc_val[0][s->block_index[i]] = 0;
3658 GET_MVDATA(dmv_x, dmv_y);
3660 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3662 vc1_mc_4mv_luma(v, i, 0, 0);
3663 intra_count += s->mb_intra;
3664 is_intra[i] = s->mb_intra;
3665 is_coded[i] = mb_has_coeffs;
3668 is_intra[i] = (intra_count >= 3);
3672 vc1_mc_4mv_chroma(v, 0);
3673 v->mb_type[0][s->block_index[i]] = is_intra[i];
3675 coded_inter = !is_intra[i] & is_coded[i];
3677 // if there are no coded blocks then don't do anything more
3679 if (!intra_count && !coded_inter)
3682 s->current_picture.qscale_table[mb_pos] = mquant;
3683 /* test if block is intra and has pred */
3686 for (i = 0; i < 6; i++)
3688 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3689 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3695 s->ac_pred = get_bits1(gb);
3699 if (!v->ttmbf && coded_inter)
3700 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3701 for (i = 0; i < 6; i++) {
3703 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3704 s->mb_intra = is_intra[i];
3706 /* check if prediction blocks A and C are available */
3707 v->a_avail = v->c_avail = 0;
3708 if (i == 2 || i == 3 || !s->first_slice_line)
3709 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3710 if (i == 1 || i == 3 || s->mb_x)
3711 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3713 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3714 (i & 4) ? v->codingset2 : v->codingset);
3715 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3717 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3719 for (j = 0; j < 64; j++)
3720 s->block[i][j] <<= 1;
3721 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3722 (i & 4) ? s->uvlinesize : s->linesize);
3723 if (v->pq >= 9 && v->overlap) {
3725 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3727 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3729 block_cbp |= 0xF << (i << 2);
3730 block_intra |= 1 << i;
3731 } else if (is_coded[i]) {
3732 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3733 first_block, s->dest[dst_idx] + off,
3734 (i & 4) ? s->uvlinesize : s->linesize,
3735 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3737 block_cbp |= pat << (i << 2);
3738 if (!v->ttmbf && ttmb < 8)
3743 } else { // skipped MB
3745 s->current_picture.qscale_table[mb_pos] = 0;
3746 for (i = 0; i < 6; i++) {
3747 v->mb_type[0][s->block_index[i]] = 0;
3748 s->dc_val[0][s->block_index[i]] = 0;
3750 for (i = 0; i < 4; i++) {
3751 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3752 vc1_mc_4mv_luma(v, i, 0, 0);
3754 vc1_mc_4mv_chroma(v, 0);
3755 s->current_picture.qscale_table[mb_pos] = 0;
3759 v->cbp[s->mb_x] = block_cbp;
3760 v->ttblk[s->mb_x] = block_tt;
3761 v->is_intra[s->mb_x] = block_intra;
3766 /* Decode one macroblock in an interlaced frame p picture */
3768 static int vc1_decode_p_mb_intfr(VC1Context *v)
3770 MpegEncContext *s = &v->s;
3771 GetBitContext *gb = &s->gb;
3773 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3774 int cbp = 0; /* cbp decoding stuff */
3775 int mqdiff, mquant; /* MB quantization */
3776 int ttmb = v->ttfrm; /* MB Transform type */
3778 int mb_has_coeffs = 1; /* last_flag */
3779 int dmv_x, dmv_y; /* Differential MV components */
3780 int val; /* temp value */
3781 int first_block = 1;
3783 int skipped, fourmv = 0, twomv = 0;
3784 int block_cbp = 0, pat, block_tt = 0;
3785 int idx_mbmode = 0, mvbp;
3786 int stride_y, fieldtx;
3788 mquant = v->pq; /* Lossy initialization */
3791 skipped = get_bits1(gb);
3793 skipped = v->s.mbskip_table[mb_pos];
3795 if (v->fourmvswitch)
3796 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3798 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3799 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3800 /* store the motion vector type in a flag (useful later) */
3801 case MV_PMODE_INTFR_4MV:
3803 v->blk_mv_type[s->block_index[0]] = 0;
3804 v->blk_mv_type[s->block_index[1]] = 0;
3805 v->blk_mv_type[s->block_index[2]] = 0;
3806 v->blk_mv_type[s->block_index[3]] = 0;
3808 case MV_PMODE_INTFR_4MV_FIELD:
3810 v->blk_mv_type[s->block_index[0]] = 1;
3811 v->blk_mv_type[s->block_index[1]] = 1;
3812 v->blk_mv_type[s->block_index[2]] = 1;
3813 v->blk_mv_type[s->block_index[3]] = 1;
3815 case MV_PMODE_INTFR_2MV_FIELD:
3817 v->blk_mv_type[s->block_index[0]] = 1;
3818 v->blk_mv_type[s->block_index[1]] = 1;
3819 v->blk_mv_type[s->block_index[2]] = 1;
3820 v->blk_mv_type[s->block_index[3]] = 1;
3822 case MV_PMODE_INTFR_1MV:
3823 v->blk_mv_type[s->block_index[0]] = 0;
3824 v->blk_mv_type[s->block_index[1]] = 0;
3825 v->blk_mv_type[s->block_index[2]] = 0;
3826 v->blk_mv_type[s->block_index[3]] = 0;
3829 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3830 for (i = 0; i < 4; i++) {
3831 s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
3832 s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
3834 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3835 s->mb_intra = v->is_intra[s->mb_x] = 1;
3836 for (i = 0; i < 6; i++)
3837 v->mb_type[0][s->block_index[i]] = 1;
3838 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3839 mb_has_coeffs = get_bits1(gb);
3841 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3842 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3844 s->current_picture.qscale_table[mb_pos] = mquant;
3845 /* Set DC scale - y and c use the same (not sure if necessary here) */
3846 s->y_dc_scale = s->y_dc_scale_table[mquant];
3847 s->c_dc_scale = s->c_dc_scale_table[mquant];
3849 for (i = 0; i < 6; i++) {
3850 s->dc_val[0][s->block_index[i]] = 0;
3852 val = ((cbp >> (5 - i)) & 1);
3853 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3854 v->a_avail = v->c_avail = 0;
3855 if (i == 2 || i == 3 || !s->first_slice_line)
3856 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3857 if (i == 1 || i == 3 || s->mb_x)
3858 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3860 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3861 (i & 4) ? v->codingset2 : v->codingset);
3862 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3863 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3865 stride_y = s->linesize << fieldtx;
3866 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3868 stride_y = s->uvlinesize;
3871 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3875 } else { // inter MB
3876 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3878 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3879 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3880 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3882 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3883 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3884 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3887 s->mb_intra = v->is_intra[s->mb_x] = 0;
3888 for (i = 0; i < 6; i++)
3889 v->mb_type[0][s->block_index[i]] = 0;
3890 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3891 /* for all motion vector read MVDATA and motion compensate each block */
3895 for (i = 0; i < 6; i++) {
3898 val = ((mvbp >> (3 - i)) & 1);
3900 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3902 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0);
3903 vc1_mc_4mv_luma(v, i, 0, 0);
3904 } else if (i == 4) {
3905 vc1_mc_4mv_chroma4(v, 0, 0, 0);
3912 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3914 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3915 vc1_mc_4mv_luma(v, 0, 0, 0);
3916 vc1_mc_4mv_luma(v, 1, 0, 0);
3919 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3921 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3922 vc1_mc_4mv_luma(v, 2, 0, 0);
3923 vc1_mc_4mv_luma(v, 3, 0, 0);
3924 vc1_mc_4mv_chroma4(v, 0, 0, 0);
3926 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3929 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3931 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3935 GET_MQUANT(); // p. 227
3936 s->current_picture.qscale_table[mb_pos] = mquant;
3937 if (!v->ttmbf && cbp)
3938 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3939 for (i = 0; i < 6; i++) {
3940 s->dc_val[0][s->block_index[i]] = 0;
3942 val = ((cbp >> (5 - i)) & 1);
3944 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3946 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3948 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3949 first_block, s->dest[dst_idx] + off,
3950 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3951 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3952 block_cbp |= pat << (i << 2);
3953 if (!v->ttmbf && ttmb < 8)
3960 s->mb_intra = v->is_intra[s->mb_x] = 0;
3961 for (i = 0; i < 6; i++) {
3962 v->mb_type[0][s->block_index[i]] = 0;
3963 s->dc_val[0][s->block_index[i]] = 0;
3965 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3966 s->current_picture.qscale_table[mb_pos] = 0;
3967 v->blk_mv_type[s->block_index[0]] = 0;
3968 v->blk_mv_type[s->block_index[1]] = 0;
3969 v->blk_mv_type[s->block_index[2]] = 0;
3970 v->blk_mv_type[s->block_index[3]] = 0;
3971 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3974 if (s->mb_x == s->mb_width - 1)
3975 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3979 static int vc1_decode_p_mb_intfi(VC1Context *v)
3981 MpegEncContext *s = &v->s;
3982 GetBitContext *gb = &s->gb;
3984 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3985 int cbp = 0; /* cbp decoding stuff */
3986 int mqdiff, mquant; /* MB quantization */
3987 int ttmb = v->ttfrm; /* MB Transform type */
3989 int mb_has_coeffs = 1; /* last_flag */
3990 int dmv_x, dmv_y; /* Differential MV components */
3991 int val; /* temp values */
3992 int first_block = 1;
3995 int block_cbp = 0, pat, block_tt = 0;
3998 mquant = v->pq; /* Lossy initialization */
4000 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4001 if (idx_mbmode <= 1) { // intra MB
4002 s->mb_intra = v->is_intra[s->mb_x] = 1;
4003 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4004 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4005 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4007 s->current_picture.qscale_table[mb_pos] = mquant;
4008 /* Set DC scale - y and c use the same (not sure if necessary here) */
4009 s->y_dc_scale = s->y_dc_scale_table[mquant];
4010 s->c_dc_scale = s->c_dc_scale_table[mquant];
4011 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4012 mb_has_coeffs = idx_mbmode & 1;
4014 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4016 for (i = 0; i < 6; i++) {
4017 s->dc_val[0][s->block_index[i]] = 0;
4018 v->mb_type[0][s->block_index[i]] = 1;
4020 val = ((cbp >> (5 - i)) & 1);
4021 v->a_avail = v->c_avail = 0;
4022 if (i == 2 || i == 3 || !s->first_slice_line)
4023 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4024 if (i == 1 || i == 3 || s->mb_x)
4025 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4027 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4028 (i & 4) ? v->codingset2 : v->codingset);
4029 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4031 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4032 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4033 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4034 // TODO: loop filter
4037 s->mb_intra = v->is_intra[s->mb_x] = 0;
4038 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4039 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4040 if (idx_mbmode <= 5) { // 1-MV
4041 dmv_x = dmv_y = pred_flag = 0;
4042 if (idx_mbmode & 1) {
4043 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4045 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4047 mb_has_coeffs = !(idx_mbmode & 2);
4049 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4050 for (i = 0; i < 6; i++) {
4052 dmv_x = dmv_y = pred_flag = 0;
4053 val = ((v->fourmvbp >> (3 - i)) & 1);
4055 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4057 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4058 vc1_mc_4mv_luma(v, i, 0, 0);
4060 vc1_mc_4mv_chroma(v, 0);
4062 mb_has_coeffs = idx_mbmode & 1;
4065 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4069 s->current_picture.qscale_table[mb_pos] = mquant;
4070 if (!v->ttmbf && cbp) {
4071 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4074 for (i = 0; i < 6; i++) {
4075 s->dc_val[0][s->block_index[i]] = 0;
4077 val = ((cbp >> (5 - i)) & 1);
4078 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4080 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4081 first_block, s->dest[dst_idx] + off,
4082 (i & 4) ? s->uvlinesize : s->linesize,
4083 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
4085 block_cbp |= pat << (i << 2);
4086 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4091 if (s->mb_x == s->mb_width - 1)
4092 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4096 /** Decode one B-frame MB (in Main profile)
4098 static void vc1_decode_b_mb(VC1Context *v)
4100 MpegEncContext *s = &v->s;
4101 GetBitContext *gb = &s->gb;
4103 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4104 int cbp = 0; /* cbp decoding stuff */
4105 int mqdiff, mquant; /* MB quantization */
4106 int ttmb = v->ttfrm; /* MB Transform type */
4107 int mb_has_coeffs = 0; /* last_flag */
4108 int index, index1; /* LUT indexes */
4109 int val, sign; /* temp values */
4110 int first_block = 1;
4112 int skipped, direct;
4113 int dmv_x[2], dmv_y[2];
4114 int bmvtype = BMV_TYPE_BACKWARD;
4116 mquant = v->pq; /* lossy initialization */
4120 direct = get_bits1(gb);
4122 direct = v->direct_mb_plane[mb_pos];
4124 skipped = get_bits1(gb);
4126 skipped = v->s.mbskip_table[mb_pos];
4128 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4129 for (i = 0; i < 6; i++) {
4130 v->mb_type[0][s->block_index[i]] = 0;
4131 s->dc_val[0][s->block_index[i]] = 0;
4133 s->current_picture.qscale_table[mb_pos] = 0;
4137 GET_MVDATA(dmv_x[0], dmv_y[0]);
4138 dmv_x[1] = dmv_x[0];
4139 dmv_y[1] = dmv_y[0];
4141 if (skipped || !s->mb_intra) {
4142 bmvtype = decode012(gb);
4145 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4148 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4151 bmvtype = BMV_TYPE_INTERPOLATED;
4152 dmv_x[0] = dmv_y[0] = 0;
4156 for (i = 0; i < 6; i++)
4157 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4161 bmvtype = BMV_TYPE_INTERPOLATED;
4162 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4163 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4167 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4170 s->current_picture.qscale_table[mb_pos] = mquant;
4172 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4173 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4174 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4175 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4177 if (!mb_has_coeffs && !s->mb_intra) {
4178 /* no coded blocks - effectively skipped */
4179 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4180 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4183 if (s->mb_intra && !mb_has_coeffs) {
4185 s->current_picture.qscale_table[mb_pos] = mquant;
4186 s->ac_pred = get_bits1(gb);
4188 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4190 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4191 GET_MVDATA(dmv_x[0], dmv_y[0]);
4192 if (!mb_has_coeffs) {
4193 /* interpolated skipped block */
4194 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4195 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4199 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4201 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4204 s->ac_pred = get_bits1(gb);
4205 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4207 s->current_picture.qscale_table[mb_pos] = mquant;
4208 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4209 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4213 for (i = 0; i < 6; i++) {
4214 s->dc_val[0][s->block_index[i]] = 0;
4216 val = ((cbp >> (5 - i)) & 1);
4217 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4218 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4220 /* check if prediction blocks A and C are available */
4221 v->a_avail = v->c_avail = 0;
4222 if (i == 2 || i == 3 || !s->first_slice_line)
4223 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4224 if (i == 1 || i == 3 || s->mb_x)
4225 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4227 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4228 (i & 4) ? v->codingset2 : v->codingset);
4229 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4231 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4233 for (j = 0; j < 64; j++)
4234 s->block[i][j] <<= 1;
4235 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4237 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4238 first_block, s->dest[dst_idx] + off,
4239 (i & 4) ? s->uvlinesize : s->linesize,
4240 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4241 if (!v->ttmbf && ttmb < 8)
4248 /** Decode one B-frame MB (in interlaced field B picture)
4250 static void vc1_decode_b_mb_intfi(VC1Context *v)
4252 MpegEncContext *s = &v->s;
4253 GetBitContext *gb = &s->gb;
4255 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4256 int cbp = 0; /* cbp decoding stuff */
4257 int mqdiff, mquant; /* MB quantization */
4258 int ttmb = v->ttfrm; /* MB Transform type */
4259 int mb_has_coeffs = 0; /* last_flag */
4260 int val; /* temp value */
4261 int first_block = 1;
4264 int dmv_x[2], dmv_y[2], pred_flag[2];
4265 int bmvtype = BMV_TYPE_BACKWARD;
4268 mquant = v->pq; /* Lossy initialization */
4271 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4272 if (idx_mbmode <= 1) { // intra MB
4273 s->mb_intra = v->is_intra[s->mb_x] = 1;
4274 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4275 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4276 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4278 s->current_picture.qscale_table[mb_pos] = mquant;
4279 /* Set DC scale - y and c use the same (not sure if necessary here) */
4280 s->y_dc_scale = s->y_dc_scale_table[mquant];
4281 s->c_dc_scale = s->c_dc_scale_table[mquant];
4282 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4283 mb_has_coeffs = idx_mbmode & 1;
4285 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4287 for (i = 0; i < 6; i++) {
4288 s->dc_val[0][s->block_index[i]] = 0;
4290 val = ((cbp >> (5 - i)) & 1);
4291 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4292 v->a_avail = v->c_avail = 0;
4293 if (i == 2 || i == 3 || !s->first_slice_line)
4294 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4295 if (i == 1 || i == 3 || s->mb_x)
4296 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4298 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4299 (i & 4) ? v->codingset2 : v->codingset);
4300 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4302 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4304 for (j = 0; j < 64; j++)
4305 s->block[i][j] <<= 1;
4306 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4307 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4308 // TODO: yet to perform loop filter
4311 s->mb_intra = v->is_intra[s->mb_x] = 0;
4312 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4313 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4315 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4317 fwd = v->forward_mb_plane[mb_pos];
4318 if (idx_mbmode <= 5) { // 1-MV
4320 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4321 pred_flag[0] = pred_flag[1] = 0;
4323 bmvtype = BMV_TYPE_FORWARD;
4325 bmvtype = decode012(gb);
4328 bmvtype = BMV_TYPE_BACKWARD;
4331 bmvtype = BMV_TYPE_DIRECT;
4334 bmvtype = BMV_TYPE_INTERPOLATED;
4335 interpmvp = get_bits1(gb);
4338 v->bmvtype = bmvtype;
4339 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4340 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4343 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4345 if (bmvtype == BMV_TYPE_DIRECT) {
4346 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4347 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4348 if (!s->next_picture_ptr->field_picture) {
4349 av_log(s->avctx, AV_LOG_ERROR, "Mixed field/frame direct mode not supported\n");
4353 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4354 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4355 mb_has_coeffs = !(idx_mbmode & 2);
4358 bmvtype = BMV_TYPE_FORWARD;
4359 v->bmvtype = bmvtype;
4360 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4361 for (i = 0; i < 6; i++) {
4363 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4364 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4365 val = ((v->fourmvbp >> (3 - i)) & 1);
4367 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4368 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4369 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4371 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4372 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD, 0);
4374 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4376 mb_has_coeffs = idx_mbmode & 1;
4379 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4383 s->current_picture.qscale_table[mb_pos] = mquant;
4384 if (!v->ttmbf && cbp) {
4385 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4388 for (i = 0; i < 6; i++) {
4389 s->dc_val[0][s->block_index[i]] = 0;
4391 val = ((cbp >> (5 - i)) & 1);
4392 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4394 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4395 first_block, s->dest[dst_idx] + off,
4396 (i & 4) ? s->uvlinesize : s->linesize,
4397 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4398 if (!v->ttmbf && ttmb < 8)
4406 /** Decode one B-frame MB (in interlaced frame B picture)
4408 static int vc1_decode_b_mb_intfr(VC1Context *v)
4410 MpegEncContext *s = &v->s;
4411 GetBitContext *gb = &s->gb;
4413 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4414 int cbp = 0; /* cbp decoding stuff */
4415 int mqdiff, mquant; /* MB quantization */
4416 int ttmb = v->ttfrm; /* MB Transform type */
4417 int mvsw = 0; /* motion vector switch */
4418 int mb_has_coeffs = 1; /* last_flag */
4419 int dmv_x, dmv_y; /* Differential MV components */
4420 int val; /* temp value */
4421 int first_block = 1;
4423 int skipped, direct, twomv = 0;
4424 int block_cbp = 0, pat, block_tt = 0;
4425 int idx_mbmode = 0, mvbp;
4426 int stride_y, fieldtx;
4427 int bmvtype = BMV_TYPE_BACKWARD;
4430 mquant = v->pq; /* Lossy initialization */
4433 skipped = get_bits1(gb);
4435 skipped = v->s.mbskip_table[mb_pos];
4438 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
4439 if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
4441 v->blk_mv_type[s->block_index[0]] = 1;
4442 v->blk_mv_type[s->block_index[1]] = 1;
4443 v->blk_mv_type[s->block_index[2]] = 1;
4444 v->blk_mv_type[s->block_index[3]] = 1;
4446 v->blk_mv_type[s->block_index[0]] = 0;
4447 v->blk_mv_type[s->block_index[1]] = 0;
4448 v->blk_mv_type[s->block_index[2]] = 0;
4449 v->blk_mv_type[s->block_index[3]] = 0;
4454 direct = get_bits1(gb);
4456 direct = v->direct_mb_plane[mb_pos];
4459 if (s->next_picture_ptr->field_picture)
4460 av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
4461 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);
4462 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);
4463 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);
4464 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);
4467 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);
4468 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);
4469 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);
4470 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);
4472 for (i = 1; i < 4; i += 2) {
4473 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
4474 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
4475 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
4476 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
4479 for (i = 1; i < 4; i++) {
4480 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
4481 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
4482 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
4483 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
4488 if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
4489 for (i = 0; i < 4; i++) {
4490 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;
4491 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;
4492 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
4493 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
4495 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4496 s->mb_intra = v->is_intra[s->mb_x] = 1;
4497 for (i = 0; i < 6; i++)
4498 v->mb_type[0][s->block_index[i]] = 1;
4499 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
4500 mb_has_coeffs = get_bits1(gb);
4502 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4503 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4505 s->current_picture.qscale_table[mb_pos] = mquant;
4506 /* Set DC scale - y and c use the same (not sure if necessary here) */
4507 s->y_dc_scale = s->y_dc_scale_table[mquant];
4508 s->c_dc_scale = s->c_dc_scale_table[mquant];
4510 for (i = 0; i < 6; i++) {
4511 s->dc_val[0][s->block_index[i]] = 0;
4513 val = ((cbp >> (5 - i)) & 1);
4514 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4515 v->a_avail = v->c_avail = 0;
4516 if (i == 2 || i == 3 || !s->first_slice_line)
4517 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4518 if (i == 1 || i == 3 || s->mb_x)
4519 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4521 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4522 (i & 4) ? v->codingset2 : v->codingset);
4523 if (i > 3 && (s->flags & CODEC_FLAG_GRAY))
4525 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4527 stride_y = s->linesize << fieldtx;
4528 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
4530 stride_y = s->uvlinesize;
4533 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
4536 s->mb_intra = v->is_intra[s->mb_x] = 0;
4538 if (skipped || !s->mb_intra) {
4539 bmvtype = decode012(gb);
4542 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4545 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4548 bmvtype = BMV_TYPE_INTERPOLATED;
4552 if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
4553 mvsw = get_bits1(gb);
4556 if (!skipped) { // inter MB
4557 mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
4559 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4561 if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
4562 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4563 } else if (bmvtype == BMV_TYPE_INTERPOLATED || twomv) {
4564 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
4568 for (i = 0; i < 6; i++)
4569 v->mb_type[0][s->block_index[i]] = 0;
4570 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1];
4571 /* for all motion vector read MVDATA and motion compensate each block */
4575 for (i = 0; i < 4; i++) {
4576 vc1_mc_4mv_luma(v, i, 0, 0);
4577 vc1_mc_4mv_luma(v, i, 1, 1);
4579 vc1_mc_4mv_chroma4(v, 0, 0, 0);
4580 vc1_mc_4mv_chroma4(v, 1, 1, 1);
4585 } else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) {
4587 for (i = 0; i < 4; i++) {
4590 val = ((mvbp >> (3 - i)) & 1);
4592 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4594 vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4595 vc1_mc_4mv_luma(v, j, dir, dir);
4596 vc1_mc_4mv_luma(v, j+1, dir, dir);
4599 vc1_mc_4mv_chroma4(v, 0, 0, 0);
4600 vc1_mc_4mv_chroma4(v, 1, 1, 1);
4601 } else if (bmvtype == BMV_TYPE_INTERPOLATED) {
4605 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4607 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4612 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4614 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4617 dir = bmvtype == BMV_TYPE_BACKWARD;
4624 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4625 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4629 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4630 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir2);
4633 for (i = 0; i < 2; i++) {
4634 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];
4635 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];
4636 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];
4637 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];
4640 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4641 vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4644 vc1_mc_4mv_luma(v, 0, dir, 0);
4645 vc1_mc_4mv_luma(v, 1, dir, 0);
4646 vc1_mc_4mv_luma(v, 2, dir2, 0);
4647 vc1_mc_4mv_luma(v, 3, dir2, 0);
4648 vc1_mc_4mv_chroma4(v, dir, dir2, 0);
4650 dir = bmvtype == BMV_TYPE_BACKWARD;
4652 mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2];
4655 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4657 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4658 v->blk_mv_type[s->block_index[0]] = 1;
4659 v->blk_mv_type[s->block_index[1]] = 1;
4660 v->blk_mv_type[s->block_index[2]] = 1;
4661 v->blk_mv_type[s->block_index[3]] = 1;
4662 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4663 for (i = 0; i < 2; i++) {
4664 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];
4665 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];
4671 GET_MQUANT(); // p. 227
4672 s->current_picture.qscale_table[mb_pos] = mquant;
4673 if (!v->ttmbf && cbp)
4674 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4675 for (i = 0; i < 6; i++) {
4676 s->dc_val[0][s->block_index[i]] = 0;
4678 val = ((cbp >> (5 - i)) & 1);
4680 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4682 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
4684 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4685 first_block, s->dest[dst_idx] + off,
4686 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
4687 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
4688 block_cbp |= pat << (i << 2);
4689 if (!v->ttmbf && ttmb < 8)
4697 for (i = 0; i < 6; i++) {
4698 v->mb_type[0][s->block_index[i]] = 0;
4699 s->dc_val[0][s->block_index[i]] = 0;
4701 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
4702 s->current_picture.qscale_table[mb_pos] = 0;
4703 v->blk_mv_type[s->block_index[0]] = 0;
4704 v->blk_mv_type[s->block_index[1]] = 0;
4705 v->blk_mv_type[s->block_index[2]] = 0;
4706 v->blk_mv_type[s->block_index[3]] = 0;
4709 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4710 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4711 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4713 dir = bmvtype == BMV_TYPE_BACKWARD;
4714 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4719 for (i = 0; i < 2; i++) {
4720 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];
4721 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];
4722 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];
4723 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];
4726 v->blk_mv_type[s->block_index[0]] = 1;
4727 v->blk_mv_type[s->block_index[1]] = 1;
4728 v->blk_mv_type[s->block_index[2]] = 1;
4729 v->blk_mv_type[s->block_index[3]] = 1;
4730 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4731 for (i = 0; i < 2; i++) {
4732 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];
4733 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];
4740 if (direct || bmvtype == BMV_TYPE_INTERPOLATED) {
4745 if (s->mb_x == s->mb_width - 1)
4746 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4747 v->cbp[s->mb_x] = block_cbp;
4748 v->ttblk[s->mb_x] = block_tt;
4752 /** Decode blocks of I-frame
4754 static void vc1_decode_i_blocks(VC1Context *v)
4757 MpegEncContext *s = &v->s;
4762 /* select codingmode used for VLC tables selection */
4763 switch (v->y_ac_table_index) {
4765 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4768 v->codingset = CS_HIGH_MOT_INTRA;
4771 v->codingset = CS_MID_RATE_INTRA;
4775 switch (v->c_ac_table_index) {
4777 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4780 v->codingset2 = CS_HIGH_MOT_INTER;
4783 v->codingset2 = CS_MID_RATE_INTER;
4787 /* Set DC scale - y and c use the same */
4788 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4789 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4792 s->mb_x = s->mb_y = 0;
4794 s->first_slice_line = 1;
4795 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4797 init_block_index(v);
4798 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4800 ff_update_block_index(s);
4801 dst[0] = s->dest[0];
4802 dst[1] = dst[0] + 8;
4803 dst[2] = s->dest[0] + s->linesize * 8;
4804 dst[3] = dst[2] + 8;
4805 dst[4] = s->dest[1];
4806 dst[5] = s->dest[2];
4807 s->dsp.clear_blocks(s->block[0]);
4808 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4809 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4810 s->current_picture.qscale_table[mb_pos] = v->pq;
4811 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4812 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4814 // do actual MB decoding and displaying
4815 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4816 v->s.ac_pred = get_bits1(&v->s.gb);
4818 for (k = 0; k < 6; k++) {
4819 val = ((cbp >> (5 - k)) & 1);
4822 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4826 cbp |= val << (5 - k);
4828 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4830 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4832 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4833 if (v->pq >= 9 && v->overlap) {
4835 for (j = 0; j < 64; j++)
4836 s->block[k][j] <<= 1;
4837 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4840 for (j = 0; j < 64; j++)
4841 s->block[k][j] = (s->block[k][j] - 64) << 1;
4842 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4846 if (v->pq >= 9 && v->overlap) {
4848 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4849 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4850 if (!(s->flags & CODEC_FLAG_GRAY)) {
4851 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4852 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4855 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4856 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4857 if (!s->first_slice_line) {
4858 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4859 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4860 if (!(s->flags & CODEC_FLAG_GRAY)) {
4861 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4862 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4865 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4866 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4868 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4870 if (get_bits_count(&s->gb) > v->bits) {
4871 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4872 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4873 get_bits_count(&s->gb), v->bits);
4877 if (!v->s.loop_filter)
4878 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4880 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4882 s->first_slice_line = 0;
4884 if (v->s.loop_filter)
4885 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4887 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4888 * profile, these only differ are when decoding MSS2 rectangles. */
4889 ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4892 /** Decode blocks of I-frame for advanced profile
4894 static void vc1_decode_i_blocks_adv(VC1Context *v)
4897 MpegEncContext *s = &v->s;
4903 GetBitContext *gb = &s->gb;
4905 /* select codingmode used for VLC tables selection */
4906 switch (v->y_ac_table_index) {
4908 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4911 v->codingset = CS_HIGH_MOT_INTRA;
4914 v->codingset = CS_MID_RATE_INTRA;
4918 switch (v->c_ac_table_index) {
4920 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4923 v->codingset2 = CS_HIGH_MOT_INTER;
4926 v->codingset2 = CS_MID_RATE_INTER;
4931 s->mb_x = s->mb_y = 0;
4933 s->first_slice_line = 1;
4934 s->mb_y = s->start_mb_y;
4935 if (s->start_mb_y) {
4937 init_block_index(v);
4938 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4939 (1 + s->b8_stride) * sizeof(*s->coded_block));
4941 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4943 init_block_index(v);
4944 for (;s->mb_x < s->mb_width; s->mb_x++) {
4945 int16_t (*block)[64] = v->block[v->cur_blk_idx];
4946 ff_update_block_index(s);
4947 s->dsp.clear_blocks(block[0]);
4948 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4949 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4950 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4951 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4953 // do actual MB decoding and displaying
4954 if (v->fieldtx_is_raw)
4955 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4956 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4957 if ( v->acpred_is_raw)
4958 v->s.ac_pred = get_bits1(&v->s.gb);
4960 v->s.ac_pred = v->acpred_plane[mb_pos];
4962 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4963 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4967 s->current_picture.qscale_table[mb_pos] = mquant;
4968 /* Set DC scale - y and c use the same */
4969 s->y_dc_scale = s->y_dc_scale_table[mquant];
4970 s->c_dc_scale = s->c_dc_scale_table[mquant];
4972 for (k = 0; k < 6; k++) {
4973 val = ((cbp >> (5 - k)) & 1);
4976 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4980 cbp |= val << (5 - k);
4982 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4983 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4985 vc1_decode_i_block_adv(v, block[k], k, val,
4986 (k < 4) ? v->codingset : v->codingset2, mquant);
4988 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4990 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4993 vc1_smooth_overlap_filter_iblk(v);
4994 vc1_put_signed_blocks_clamped(v);
4995 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4997 if (get_bits_count(&s->gb) > v->bits) {
4998 // TODO: may need modification to handle slice coding
4999 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5000 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
5001 get_bits_count(&s->gb), v->bits);
5005 if (!v->s.loop_filter)
5006 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5008 ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
5009 s->first_slice_line = 0;
5012 /* raw bottom MB row */
5014 init_block_index(v);
5016 for (;s->mb_x < s->mb_width; s->mb_x++) {
5017 ff_update_block_index(s);
5018 vc1_put_signed_blocks_clamped(v);
5019 if (v->s.loop_filter)
5020 vc1_loop_filter_iblk_delayed(v, v->pq);
5022 if (v->s.loop_filter)
5023 ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
5024 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5025 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5028 static void vc1_decode_p_blocks(VC1Context *v)
5030 MpegEncContext *s = &v->s;
5031 int apply_loop_filter;
5033 /* select codingmode used for VLC tables selection */
5034 switch (v->c_ac_table_index) {
5036 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5039 v->codingset = CS_HIGH_MOT_INTRA;
5042 v->codingset = CS_MID_RATE_INTRA;
5046 switch (v->c_ac_table_index) {
5048 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5051 v->codingset2 = CS_HIGH_MOT_INTER;
5054 v->codingset2 = CS_MID_RATE_INTER;
5058 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY) &&
5059 v->fcm == PROGRESSIVE;
5060 s->first_slice_line = 1;
5061 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
5062 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5064 init_block_index(v);
5065 for (; s->mb_x < s->mb_width; s->mb_x++) {
5066 ff_update_block_index(s);
5068 if (v->fcm == ILACE_FIELD)
5069 vc1_decode_p_mb_intfi(v);
5070 else if (v->fcm == ILACE_FRAME)
5071 vc1_decode_p_mb_intfr(v);
5072 else vc1_decode_p_mb(v);
5073 if (s->mb_y != s->start_mb_y && apply_loop_filter)
5074 vc1_apply_p_loop_filter(v);
5075 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5076 // TODO: may need modification to handle slice coding
5077 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5078 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5079 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5083 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
5084 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
5085 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
5086 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
5087 if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5088 s->first_slice_line = 0;
5090 if (apply_loop_filter) {
5092 init_block_index(v);
5093 for (; s->mb_x < s->mb_width; s->mb_x++) {
5094 ff_update_block_index(s);
5095 vc1_apply_p_loop_filter(v);
5098 if (s->end_mb_y >= s->start_mb_y)
5099 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5100 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5101 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5104 static void vc1_decode_b_blocks(VC1Context *v)
5106 MpegEncContext *s = &v->s;
5108 /* select codingmode used for VLC tables selection */
5109 switch (v->c_ac_table_index) {
5111 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5114 v->codingset = CS_HIGH_MOT_INTRA;
5117 v->codingset = CS_MID_RATE_INTRA;
5121 switch (v->c_ac_table_index) {
5123 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5126 v->codingset2 = CS_HIGH_MOT_INTER;
5129 v->codingset2 = CS_MID_RATE_INTER;
5133 s->first_slice_line = 1;
5134 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5136 init_block_index(v);
5137 for (; s->mb_x < s->mb_width; s->mb_x++) {
5138 ff_update_block_index(s);
5140 if (v->fcm == ILACE_FIELD)
5141 vc1_decode_b_mb_intfi(v);
5142 else if (v->fcm == ILACE_FRAME)
5143 vc1_decode_b_mb_intfr(v);
5146 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5147 // TODO: may need modification to handle slice coding
5148 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5149 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5150 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5153 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
5155 if (!v->s.loop_filter)
5156 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5158 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5159 s->first_slice_line = 0;
5161 if (v->s.loop_filter)
5162 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5163 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5164 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5167 static void vc1_decode_skip_blocks(VC1Context *v)
5169 MpegEncContext *s = &v->s;
5171 if (!v->s.last_picture.f.data[0])
5174 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
5175 s->first_slice_line = 1;
5176 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5178 init_block_index(v);
5179 ff_update_block_index(s);
5180 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
5181 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5182 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5183 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5184 s->first_slice_line = 0;
5186 s->pict_type = AV_PICTURE_TYPE_P;
5189 void ff_vc1_decode_blocks(VC1Context *v)
5192 v->s.esc3_level_length = 0;
5194 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
5197 v->left_blk_idx = -1;
5198 v->topleft_blk_idx = 1;
5200 switch (v->s.pict_type) {
5201 case AV_PICTURE_TYPE_I:
5202 if (v->profile == PROFILE_ADVANCED)
5203 vc1_decode_i_blocks_adv(v);
5205 vc1_decode_i_blocks(v);
5207 case AV_PICTURE_TYPE_P:
5208 if (v->p_frame_skipped)
5209 vc1_decode_skip_blocks(v);
5211 vc1_decode_p_blocks(v);
5213 case AV_PICTURE_TYPE_B:
5215 if (v->profile == PROFILE_ADVANCED)
5216 vc1_decode_i_blocks_adv(v);
5218 vc1_decode_i_blocks(v);
5220 vc1_decode_b_blocks(v);
5226 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5230 * Transform coefficients for both sprites in 16.16 fixed point format,
5231 * in the order they appear in the bitstream:
5233 * rotation 1 (unused)
5235 * rotation 2 (unused)
5242 int effect_type, effect_flag;
5243 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
5244 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
5247 static inline int get_fp_val(GetBitContext* gb)
5249 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
5252 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
5256 switch (get_bits(gb, 2)) {
5259 c[2] = get_fp_val(gb);
5263 c[0] = c[4] = get_fp_val(gb);
5264 c[2] = get_fp_val(gb);
5267 c[0] = get_fp_val(gb);
5268 c[2] = get_fp_val(gb);
5269 c[4] = get_fp_val(gb);
5272 c[0] = get_fp_val(gb);
5273 c[1] = get_fp_val(gb);
5274 c[2] = get_fp_val(gb);
5275 c[3] = get_fp_val(gb);
5276 c[4] = get_fp_val(gb);
5279 c[5] = get_fp_val(gb);
5281 c[6] = get_fp_val(gb);
5286 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
5288 AVCodecContext *avctx = v->s.avctx;
5291 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5292 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
5293 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
5294 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
5295 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
5296 for (i = 0; i < 7; i++)
5297 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
5298 sd->coefs[sprite][i] / (1<<16),
5299 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
5300 av_log(avctx, AV_LOG_DEBUG, "\n");
5304 if (sd->effect_type = get_bits_long(gb, 30)) {
5305 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
5307 vc1_sprite_parse_transform(gb, sd->effect_params1);
5310 vc1_sprite_parse_transform(gb, sd->effect_params1);
5311 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
5314 for (i = 0; i < sd->effect_pcount1; i++)
5315 sd->effect_params1[i] = get_fp_val(gb);
5317 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
5318 // effect 13 is simple alpha blending and matches the opacity above
5319 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
5320 for (i = 0; i < sd->effect_pcount1; i++)
5321 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5322 sd->effect_params1[i] / (1 << 16),
5323 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
5324 av_log(avctx, AV_LOG_DEBUG, "\n");
5327 sd->effect_pcount2 = get_bits(gb, 16);
5328 if (sd->effect_pcount2 > 10) {
5329 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
5330 return AVERROR_INVALIDDATA;
5331 } else if (sd->effect_pcount2) {
5333 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
5334 while (++i < sd->effect_pcount2) {
5335 sd->effect_params2[i] = get_fp_val(gb);
5336 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5337 sd->effect_params2[i] / (1 << 16),
5338 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
5340 av_log(avctx, AV_LOG_DEBUG, "\n");
5343 if (sd->effect_flag = get_bits1(gb))
5344 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
5346 if (get_bits_count(gb) >= gb->size_in_bits +
5347 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
5348 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
5349 return AVERROR_INVALIDDATA;
5351 if (get_bits_count(gb) < gb->size_in_bits - 8)
5352 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
5357 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
5359 int i, plane, row, sprite;
5360 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
5361 uint8_t* src_h[2][2];
5362 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
5364 MpegEncContext *s = &v->s;
5366 for (i = 0; i <= v->two_sprites; i++) {
5367 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
5368 xadv[i] = sd->coefs[i][0];
5369 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
5370 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
5372 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
5373 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
5375 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
5377 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
5378 int width = v->output_width>>!!plane;
5380 for (row = 0; row < v->output_height>>!!plane; row++) {
5381 uint8_t *dst = v->sprite_output_frame->data[plane] +
5382 v->sprite_output_frame->linesize[plane] * row;
5384 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5385 uint8_t *iplane = s->current_picture.f.data[plane];
5386 int iline = s->current_picture.f.linesize[plane];
5387 int ycoord = yoff[sprite] + yadv[sprite] * row;
5388 int yline = ycoord >> 16;
5390 ysub[sprite] = ycoord & 0xFFFF;
5392 iplane = s->last_picture.f.data[plane];
5393 iline = s->last_picture.f.linesize[plane];
5395 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
5396 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
5397 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
5399 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
5401 if (sr_cache[sprite][0] != yline) {
5402 if (sr_cache[sprite][1] == yline) {
5403 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
5404 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
5406 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
5407 sr_cache[sprite][0] = yline;
5410 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
5411 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
5412 iplane + next_line, xoff[sprite],
5413 xadv[sprite], width);
5414 sr_cache[sprite][1] = yline + 1;
5416 src_h[sprite][0] = v->sr_rows[sprite][0];
5417 src_h[sprite][1] = v->sr_rows[sprite][1];
5421 if (!v->two_sprites) {
5423 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
5425 memcpy(dst, src_h[0][0], width);
5428 if (ysub[0] && ysub[1]) {
5429 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5430 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5431 } else if (ysub[0]) {
5432 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5433 src_h[1][0], alpha, width);
5434 } else if (ysub[1]) {
5435 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5436 src_h[0][0], (1<<16)-1-alpha, width);
5438 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5444 for (i = 0; i <= v->two_sprites; i++) {
5454 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5457 MpegEncContext *s = &v->s;
5458 AVCodecContext *avctx = s->avctx;
5461 memset(&sd, 0, sizeof(sd));
5463 ret = vc1_parse_sprites(v, gb, &sd);
5467 if (!s->current_picture.f.data[0]) {
5468 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5472 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5473 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5477 av_frame_unref(v->sprite_output_frame);
5478 if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
5481 vc1_draw_sprites(v, &sd);
5486 static void vc1_sprite_flush(AVCodecContext *avctx)
5488 VC1Context *v = avctx->priv_data;
5489 MpegEncContext *s = &v->s;
5490 AVFrame *f = &s->current_picture.f;
5493 /* Windows Media Image codecs have a convergence interval of two keyframes.
5494 Since we can't enforce it, clear to black the missing sprite. This is
5495 wrong but it looks better than doing nothing. */
5498 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5499 for (i = 0; i < v->sprite_height>>!!plane; i++)
5500 memset(f->data[plane] + i * f->linesize[plane],
5501 plane ? 128 : 0, f->linesize[plane]);
5506 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5508 MpegEncContext *s = &v->s;
5510 int mb_height = FFALIGN(s->mb_height, 2);
5512 /* Allocate mb bitplanes */
5513 v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
5514 v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
5515 v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
5516 v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
5517 v->acpred_plane = av_malloc (s->mb_stride * mb_height);
5518 v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
5520 v->n_allocated_blks = s->mb_width + 2;
5521 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5522 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5523 v->cbp = v->cbp_base + s->mb_stride;
5524 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5525 v->ttblk = v->ttblk_base + s->mb_stride;
5526 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5527 v->is_intra = v->is_intra_base + s->mb_stride;
5528 v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5529 v->luma_mv = v->luma_mv_base + s->mb_stride;
5531 /* allocate block type info in that way so it could be used with s->block_index[] */
5532 v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5533 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5534 v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
5535 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
5537 /* allocate memory to store block level MV info */
5538 v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5539 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5540 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
5541 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5542 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5543 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
5544 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5545 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5547 /* Init coded blocks info */
5548 if (v->profile == PROFILE_ADVANCED) {
5549 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5551 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5555 ff_intrax8_common_init(&v->x8,s);
5557 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5558 for (i = 0; i < 4; i++)
5559 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
5560 return AVERROR(ENOMEM);
5563 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5564 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5566 av_freep(&v->mv_type_mb_plane);
5567 av_freep(&v->direct_mb_plane);
5568 av_freep(&v->acpred_plane);
5569 av_freep(&v->over_flags_plane);
5570 av_freep(&v->block);
5571 av_freep(&v->cbp_base);
5572 av_freep(&v->ttblk_base);
5573 av_freep(&v->is_intra_base);
5574 av_freep(&v->luma_mv_base);
5575 av_freep(&v->mb_type_base);
5576 return AVERROR(ENOMEM);
5582 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5585 for (i = 0; i < 64; i++) {
5586 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5587 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5588 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5589 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5590 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5591 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5597 /** Initialize a VC1/WMV3 decoder
5598 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5599 * @todo TODO: Decypher remaining bits in extra_data
5601 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5603 VC1Context *v = avctx->priv_data;
5604 MpegEncContext *s = &v->s;
5608 /* save the container output size for WMImage */
5609 v->output_width = avctx->width;
5610 v->output_height = avctx->height;
5612 if (!avctx->extradata_size || !avctx->extradata)
5614 if (!(avctx->flags & CODEC_FLAG_GRAY))
5615 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5617 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5618 avctx->hwaccel = ff_find_hwaccel(avctx);
5621 if ((ret = ff_vc1_init_common(v)) < 0)
5623 // ensure static VLC tables are initialized
5624 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
5626 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
5628 // Hack to ensure the above functions will be called
5629 // again once we know all necessary settings.
5630 // That this is necessary might indicate a bug.
5631 ff_vc1_decode_end(avctx);
5633 ff_h264chroma_init(&v->h264chroma, 8);
5634 ff_vc1dsp_init(&v->vc1dsp);
5636 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5639 // looks like WMV3 has a sequence header stored in the extradata
5640 // advanced sequence header may be before the first frame
5641 // the last byte of the extradata is a version number, 1 for the
5642 // samples we can decode
5644 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5646 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
5649 count = avctx->extradata_size*8 - get_bits_count(&gb);
5651 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5652 count, get_bits(&gb, count));
5653 } else if (count < 0) {
5654 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5656 } else { // VC1/WVC1/WVP2
5657 const uint8_t *start = avctx->extradata;
5658 uint8_t *end = avctx->extradata + avctx->extradata_size;
5659 const uint8_t *next;
5660 int size, buf2_size;
5661 uint8_t *buf2 = NULL;
5662 int seq_initialized = 0, ep_initialized = 0;
5664 if (avctx->extradata_size < 16) {
5665 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5669 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5670 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5672 for (; next < end; start = next) {
5673 next = find_next_marker(start + 4, end);
5674 size = next - start - 4;
5677 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5678 init_get_bits(&gb, buf2, buf2_size * 8);
5679 switch (AV_RB32(start)) {
5680 case VC1_CODE_SEQHDR:
5681 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
5685 seq_initialized = 1;
5687 case VC1_CODE_ENTRYPOINT:
5688 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
5697 if (!seq_initialized || !ep_initialized) {
5698 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5701 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5704 v->sprite_output_frame = av_frame_alloc();
5705 if (!v->sprite_output_frame)
5706 return AVERROR(ENOMEM);
5708 avctx->profile = v->profile;
5709 if (v->profile == PROFILE_ADVANCED)
5710 avctx->level = v->level;
5712 avctx->has_b_frames = !!avctx->max_b_frames;
5714 s->mb_width = (avctx->coded_width + 15) >> 4;
5715 s->mb_height = (avctx->coded_height + 15) >> 4;
5717 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5718 ff_vc1_init_transposed_scantables(v);
5720 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5725 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5726 v->sprite_width = avctx->coded_width;
5727 v->sprite_height = avctx->coded_height;
5729 avctx->coded_width = avctx->width = v->output_width;
5730 avctx->coded_height = avctx->height = v->output_height;
5732 // prevent 16.16 overflows
5733 if (v->sprite_width > 1 << 14 ||
5734 v->sprite_height > 1 << 14 ||
5735 v->output_width > 1 << 14 ||
5736 v->output_height > 1 << 14) return -1;
5738 if ((v->sprite_width&1) || (v->sprite_height&1)) {
5739 avpriv_request_sample(avctx, "odd sprites support");
5740 return AVERROR_PATCHWELCOME;
5746 /** Close a VC1/WMV3 decoder
5747 * @warning Initial try at using MpegEncContext stuff
5749 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5751 VC1Context *v = avctx->priv_data;
5754 av_frame_free(&v->sprite_output_frame);
5756 for (i = 0; i < 4; i++)
5757 av_freep(&v->sr_rows[i >> 1][i & 1]);
5758 av_freep(&v->hrd_rate);
5759 av_freep(&v->hrd_buffer);
5760 ff_MPV_common_end(&v->s);
5761 av_freep(&v->mv_type_mb_plane);
5762 av_freep(&v->direct_mb_plane);
5763 av_freep(&v->forward_mb_plane);
5764 av_freep(&v->fieldtx_plane);
5765 av_freep(&v->acpred_plane);
5766 av_freep(&v->over_flags_plane);
5767 av_freep(&v->mb_type_base);
5768 av_freep(&v->blk_mv_type_base);
5769 av_freep(&v->mv_f_base);
5770 av_freep(&v->mv_f_next_base);
5771 av_freep(&v->block);
5772 av_freep(&v->cbp_base);
5773 av_freep(&v->ttblk_base);
5774 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5775 av_freep(&v->luma_mv_base);
5776 ff_intrax8_common_end(&v->x8);
5781 /** Decode a VC1/WMV3 frame
5782 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5784 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5785 int *got_frame, AVPacket *avpkt)
5787 const uint8_t *buf = avpkt->data;
5788 int buf_size = avpkt->size, n_slices = 0, i, ret;
5789 VC1Context *v = avctx->priv_data;
5790 MpegEncContext *s = &v->s;
5791 AVFrame *pict = data;
5792 uint8_t *buf2 = NULL;
5793 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
5794 int mb_height, n_slices1=-1;
5799 } *slices = NULL, *tmp;
5801 v->second_field = 0;
5803 if(s->flags & CODEC_FLAG_LOW_DELAY)
5806 /* no supplementary picture */
5807 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5808 /* special case for last picture */
5809 if (s->low_delay == 0 && s->next_picture_ptr) {
5810 if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
5812 s->next_picture_ptr = NULL;
5820 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5821 if (v->profile < PROFILE_ADVANCED)
5822 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5824 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5827 //for advanced profile we may need to parse and unescape data
5828 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5830 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5832 return AVERROR(ENOMEM);
5834 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5835 const uint8_t *start, *end, *next;
5839 for (start = buf, end = buf + buf_size; next < end; start = next) {
5840 next = find_next_marker(start + 4, end);
5841 size = next - start - 4;
5842 if (size <= 0) continue;
5843 switch (AV_RB32(start)) {
5844 case VC1_CODE_FRAME:
5845 if (avctx->hwaccel ||
5846 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5848 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5850 case VC1_CODE_FIELD: {
5852 if (avctx->hwaccel ||
5853 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5854 buf_start_second_field = start;
5855 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5859 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5860 if (!slices[n_slices].buf)
5862 buf_size3 = vc1_unescape_buffer(start + 4, size,
5863 slices[n_slices].buf);
5864 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5866 /* assuming that the field marker is at the exact middle,
5867 hope it's correct */
5868 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
5869 n_slices1 = n_slices - 1; // index of the last slice of the first field
5873 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5874 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5875 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5876 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5878 case VC1_CODE_SLICE: {
5880 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5884 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5885 if (!slices[n_slices].buf)
5887 buf_size3 = vc1_unescape_buffer(start + 4, size,
5888 slices[n_slices].buf);
5889 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5891 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5897 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5898 const uint8_t *divider;
5901 divider = find_next_marker(buf, buf + buf_size);
5902 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5903 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5905 } else { // found field marker, unescape second field
5906 if (avctx->hwaccel ||
5907 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5908 buf_start_second_field = divider;
5909 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5913 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5914 if (!slices[n_slices].buf)
5916 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5917 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5919 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
5920 n_slices1 = n_slices - 1;
5923 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5925 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5927 init_get_bits(&s->gb, buf2, buf_size2*8);
5929 init_get_bits(&s->gb, buf, buf_size*8);
5931 if (v->res_sprite) {
5932 v->new_sprite = !get_bits1(&s->gb);
5933 v->two_sprites = get_bits1(&s->gb);
5934 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5935 we're using the sprite compositor. These are intentionally kept separate
5936 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5937 the vc1 one for WVP2 */
5938 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5939 if (v->new_sprite) {
5940 // switch AVCodecContext parameters to those of the sprites
5941 avctx->width = avctx->coded_width = v->sprite_width;
5942 avctx->height = avctx->coded_height = v->sprite_height;
5949 if (s->context_initialized &&
5950 (s->width != avctx->coded_width ||
5951 s->height != avctx->coded_height)) {
5952 ff_vc1_decode_end(avctx);
5955 if (!s->context_initialized) {
5956 if (ff_msmpeg4_decode_init(avctx) < 0)
5958 if (ff_vc1_decode_init_alloc_tables(v) < 0) {
5959 ff_MPV_common_end(s);
5963 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5965 if (v->profile == PROFILE_ADVANCED) {
5966 if(avctx->coded_width<=1 || avctx->coded_height<=1)
5968 s->h_edge_pos = avctx->coded_width;
5969 s->v_edge_pos = avctx->coded_height;
5973 // do parse frame header
5974 v->pic_header_flag = 0;
5975 v->first_pic_header_flag = 1;
5976 if (v->profile < PROFILE_ADVANCED) {
5977 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5981 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5985 v->first_pic_header_flag = 0;
5987 if (avctx->debug & FF_DEBUG_PICT_INFO)
5988 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
5990 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5991 && s->pict_type != AV_PICTURE_TYPE_I) {
5992 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5996 if ((s->mb_height >> v->field_mode) == 0) {
5997 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
6001 // for skipping the frame
6002 s->current_picture.f.pict_type = s->pict_type;
6003 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
6005 /* skip B-frames if we don't have reference frames */
6006 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
6009 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
6010 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
6011 avctx->skip_frame >= AVDISCARD_ALL) {
6015 if (s->next_p_frame_damaged) {
6016 if (s->pict_type == AV_PICTURE_TYPE_B)
6019 s->next_p_frame_damaged = 0;
6022 if (ff_MPV_frame_start(s, avctx) < 0) {
6026 v->s.current_picture_ptr->field_picture = v->field_mode;
6027 v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
6028 v->s.current_picture_ptr->f.top_field_first = v->tff;
6030 // process pulldown flags
6031 s->current_picture_ptr->f.repeat_pict = 0;
6032 // Pulldown flags are only valid when 'broadcast' has been set.
6033 // So ticks_per_frame will be 2
6036 s->current_picture_ptr->f.repeat_pict = 1;
6037 } else if (v->rptfrm) {
6039 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
6042 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
6043 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
6045 if ((CONFIG_VC1_VDPAU_DECODER)
6046 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
6047 if (v->field_mode && buf_start_second_field) {
6048 ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
6049 ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
6051 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
6053 } else if (avctx->hwaccel) {
6054 if (v->field_mode && buf_start_second_field) {
6055 // decode first field
6056 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
6057 if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6059 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6061 if (avctx->hwaccel->end_frame(avctx) < 0)
6064 // decode second field
6065 s->gb = slices[n_slices1 + 1].gb;
6066 s->picture_structure = PICT_TOP_FIELD + v->tff;
6067 v->second_field = 1;
6068 v->pic_header_flag = 0;
6069 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
6070 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
6073 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
6075 if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6077 if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6079 if (avctx->hwaccel->end_frame(avctx) < 0)
6082 s->picture_structure = PICT_FRAME;
6083 if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6085 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6087 if (avctx->hwaccel->end_frame(avctx) < 0)
6093 ff_mpeg_er_frame_start(s);
6095 v->bits = buf_size * 8;
6096 v->end_mb_x = s->mb_width;
6097 if (v->field_mode) {
6098 s->current_picture.f.linesize[0] <<= 1;
6099 s->current_picture.f.linesize[1] <<= 1;
6100 s->current_picture.f.linesize[2] <<= 1;
6102 s->uvlinesize <<= 1;
6104 mb_height = s->mb_height >> v->field_mode;
6106 av_assert0 (mb_height > 0);
6108 for (i = 0; i <= n_slices; i++) {
6109 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
6110 if (v->field_mode <= 0) {
6111 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
6112 "picture boundary (%d >= %d)\n", i,
6113 slices[i - 1].mby_start, mb_height);
6116 v->second_field = 1;
6117 av_assert0((s->mb_height & 1) == 0);
6118 v->blocks_off = s->b8_stride * (s->mb_height&~1);
6119 v->mb_off = s->mb_stride * s->mb_height >> 1;
6121 v->second_field = 0;
6126 v->pic_header_flag = 0;
6127 if (v->field_mode && i == n_slices1 + 2) {
6128 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6129 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
6130 if (avctx->err_recognition & AV_EF_EXPLODE)
6134 } else if (get_bits1(&s->gb)) {
6135 v->pic_header_flag = 1;
6136 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6137 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
6138 if (avctx->err_recognition & AV_EF_EXPLODE)
6146 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
6147 if (!v->field_mode || v->second_field)
6148 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6150 if (i >= n_slices) {
6151 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
6154 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6156 if (s->end_mb_y <= s->start_mb_y) {
6157 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
6160 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
6161 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
6164 ff_vc1_decode_blocks(v);
6166 s->gb = slices[i].gb;
6168 if (v->field_mode) {
6169 v->second_field = 0;
6170 s->current_picture.f.linesize[0] >>= 1;
6171 s->current_picture.f.linesize[1] >>= 1;
6172 s->current_picture.f.linesize[2] >>= 1;
6174 s->uvlinesize >>= 1;
6175 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
6176 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
6177 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
6180 av_dlog(s->avctx, "Consumed %i/%i bits\n",
6181 get_bits_count(&s->gb), s->gb.size_in_bits);
6182 // if (get_bits_count(&s->gb) > buf_size * 8)
6184 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
6187 ff_er_frame_end(&s->er);
6190 ff_MPV_frame_end(s);
6192 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
6194 avctx->width = avctx->coded_width = v->output_width;
6195 avctx->height = avctx->coded_height = v->output_height;
6196 if (avctx->skip_frame >= AVDISCARD_NONREF)
6198 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
6199 if (vc1_decode_sprites(v, &s->gb))
6202 if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
6206 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
6207 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
6209 ff_print_debug_info(s, s->current_picture_ptr, pict);
6211 } else if (s->last_picture_ptr != NULL) {
6212 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
6214 ff_print_debug_info(s, s->last_picture_ptr, pict);
6221 for (i = 0; i < n_slices; i++)
6222 av_free(slices[i].buf);
6228 for (i = 0; i < n_slices; i++)
6229 av_free(slices[i].buf);
6235 static const AVProfile profiles[] = {
6236 { FF_PROFILE_VC1_SIMPLE, "Simple" },
6237 { FF_PROFILE_VC1_MAIN, "Main" },
6238 { FF_PROFILE_VC1_COMPLEX, "Complex" },
6239 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
6240 { FF_PROFILE_UNKNOWN },
6243 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
6245 AV_PIX_FMT_DXVA2_VLD,
6248 AV_PIX_FMT_VAAPI_VLD,
6257 AVCodec ff_vc1_decoder = {
6259 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
6260 .type = AVMEDIA_TYPE_VIDEO,
6261 .id = AV_CODEC_ID_VC1,
6262 .priv_data_size = sizeof(VC1Context),
6263 .init = vc1_decode_init,
6264 .close = ff_vc1_decode_end,
6265 .decode = vc1_decode_frame,
6266 .flush = ff_mpeg_flush,
6267 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6268 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6269 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6272 #if CONFIG_WMV3_DECODER
6273 AVCodec ff_wmv3_decoder = {
6275 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
6276 .type = AVMEDIA_TYPE_VIDEO,
6277 .id = AV_CODEC_ID_WMV3,
6278 .priv_data_size = sizeof(VC1Context),
6279 .init = vc1_decode_init,
6280 .close = ff_vc1_decode_end,
6281 .decode = vc1_decode_frame,
6282 .flush = ff_mpeg_flush,
6283 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6284 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6285 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6289 #if CONFIG_WMV3_VDPAU_DECODER
6290 AVCodec ff_wmv3_vdpau_decoder = {
6291 .name = "wmv3_vdpau",
6292 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
6293 .type = AVMEDIA_TYPE_VIDEO,
6294 .id = AV_CODEC_ID_WMV3,
6295 .priv_data_size = sizeof(VC1Context),
6296 .init = vc1_decode_init,
6297 .close = ff_vc1_decode_end,
6298 .decode = vc1_decode_frame,
6299 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6300 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
6301 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6305 #if CONFIG_VC1_VDPAU_DECODER
6306 AVCodec ff_vc1_vdpau_decoder = {
6307 .name = "vc1_vdpau",
6308 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
6309 .type = AVMEDIA_TYPE_VIDEO,
6310 .id = AV_CODEC_ID_VC1,
6311 .priv_data_size = sizeof(VC1Context),
6312 .init = vc1_decode_init,
6313 .close = ff_vc1_decode_end,
6314 .decode = vc1_decode_frame,
6315 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6316 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
6317 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6321 #if CONFIG_WMV3IMAGE_DECODER
6322 AVCodec ff_wmv3image_decoder = {
6323 .name = "wmv3image",
6324 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
6325 .type = AVMEDIA_TYPE_VIDEO,
6326 .id = AV_CODEC_ID_WMV3IMAGE,
6327 .priv_data_size = sizeof(VC1Context),
6328 .init = vc1_decode_init,
6329 .close = ff_vc1_decode_end,
6330 .decode = vc1_decode_frame,
6331 .capabilities = CODEC_CAP_DR1,
6332 .flush = vc1_sprite_flush,
6333 .pix_fmts = ff_pixfmt_list_420
6337 #if CONFIG_VC1IMAGE_DECODER
6338 AVCodec ff_vc1image_decoder = {
6340 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
6341 .type = AVMEDIA_TYPE_VIDEO,
6342 .id = AV_CODEC_ID_VC1IMAGE,
6343 .priv_data_size = sizeof(VC1Context),
6344 .init = vc1_decode_init,
6345 .close = ff_vc1_decode_end,
6346 .decode = vc1_decode_frame,
6347 .capabilities = CODEC_CAP_DR1,
6348 .flush = vc1_sprite_flush,
6349 .pix_fmts = ff_pixfmt_list_420