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
75 /** @} */ //imode defines
77 static void init_block_index(VC1Context *v)
79 MpegEncContext *s = &v->s;
80 ff_init_block_index(s);
81 if (v->field_mode && !(v->second_field ^ v->tff)) {
82 s->dest[0] += s->current_picture_ptr->f.linesize[0];
83 s->dest[1] += s->current_picture_ptr->f.linesize[1];
84 s->dest[2] += s->current_picture_ptr->f.linesize[2];
88 /** @} */ //Bitplane group
90 static void vc1_put_signed_blocks_clamped(VC1Context *v)
92 MpegEncContext *s = &v->s;
93 int topleft_mb_pos, top_mb_pos;
94 int stride_y, fieldtx = 0;
97 /* The put pixels loop is always one MB row behind the decoding loop,
98 * because we can only put pixels when overlap filtering is done, and
99 * for filtering of the bottom edge of a MB, we need the next MB row
101 * Within the row, the put pixels loop is also one MB col behind the
102 * decoding loop. The reason for this is again, because for filtering
103 * of the right MB edge, we need the next MB present. */
104 if (!s->first_slice_line) {
106 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
107 if (v->fcm == ILACE_FRAME)
108 fieldtx = v->fieldtx_plane[topleft_mb_pos];
109 stride_y = s->linesize << fieldtx;
110 v_dist = (16 - fieldtx) >> (fieldtx == 0);
111 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
112 s->dest[0] - 16 * s->linesize - 16,
114 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
115 s->dest[0] - 16 * s->linesize - 8,
117 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
118 s->dest[0] - v_dist * s->linesize - 16,
120 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
121 s->dest[0] - v_dist * s->linesize - 8,
123 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
124 s->dest[1] - 8 * s->uvlinesize - 8,
126 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
127 s->dest[2] - 8 * s->uvlinesize - 8,
130 if (s->mb_x == s->mb_width - 1) {
131 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
132 if (v->fcm == ILACE_FRAME)
133 fieldtx = v->fieldtx_plane[top_mb_pos];
134 stride_y = s->linesize << fieldtx;
135 v_dist = fieldtx ? 15 : 8;
136 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
137 s->dest[0] - 16 * s->linesize,
139 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
140 s->dest[0] - 16 * s->linesize + 8,
142 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
143 s->dest[0] - v_dist * s->linesize,
145 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
146 s->dest[0] - v_dist * s->linesize + 8,
148 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
149 s->dest[1] - 8 * s->uvlinesize,
151 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
152 s->dest[2] - 8 * s->uvlinesize,
157 #define inc_blk_idx(idx) do { \
159 if (idx >= v->n_allocated_blks) \
163 inc_blk_idx(v->topleft_blk_idx);
164 inc_blk_idx(v->top_blk_idx);
165 inc_blk_idx(v->left_blk_idx);
166 inc_blk_idx(v->cur_blk_idx);
169 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
171 MpegEncContext *s = &v->s;
173 if (!s->first_slice_line) {
174 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
176 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
177 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
178 for (j = 0; j < 2; j++) {
179 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
181 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
184 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
186 if (s->mb_y == s->end_mb_y - 1) {
188 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
189 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
190 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
192 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
196 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
198 MpegEncContext *s = &v->s;
201 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
202 * means it runs two rows/cols behind the decoding loop. */
203 if (!s->first_slice_line) {
205 if (s->mb_y >= s->start_mb_y + 2) {
206 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
209 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
210 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
211 for (j = 0; j < 2; j++) {
212 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
214 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
218 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
221 if (s->mb_x == s->mb_width - 1) {
222 if (s->mb_y >= s->start_mb_y + 2) {
223 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
226 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
227 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
228 for (j = 0; j < 2; j++) {
229 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
231 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
235 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
238 if (s->mb_y == s->end_mb_y) {
241 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
242 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
244 for (j = 0; j < 2; j++) {
245 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
250 if (s->mb_x == s->mb_width - 1) {
252 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
253 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
255 for (j = 0; j < 2; j++) {
256 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
264 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
266 MpegEncContext *s = &v->s;
269 if (v->condover == CONDOVER_NONE)
272 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
274 /* Within a MB, the horizontal overlap always runs before the vertical.
275 * To accomplish that, we run the H on left and internal borders of the
276 * currently decoded MB. Then, we wait for the next overlap iteration
277 * to do H overlap on the right edge of this MB, before moving over and
278 * running the V overlap. Therefore, the V overlap makes us trail by one
279 * MB col and the H overlap filter makes us trail by one MB row. This
280 * is reflected in the time at which we run the put_pixels loop. */
281 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
282 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
283 v->over_flags_plane[mb_pos - 1])) {
284 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
285 v->block[v->cur_blk_idx][0]);
286 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
287 v->block[v->cur_blk_idx][2]);
288 if (!(s->flags & CODEC_FLAG_GRAY)) {
289 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
290 v->block[v->cur_blk_idx][4]);
291 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
292 v->block[v->cur_blk_idx][5]);
295 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
296 v->block[v->cur_blk_idx][1]);
297 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
298 v->block[v->cur_blk_idx][3]);
300 if (s->mb_x == s->mb_width - 1) {
301 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
302 v->over_flags_plane[mb_pos - s->mb_stride])) {
303 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
304 v->block[v->cur_blk_idx][0]);
305 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
306 v->block[v->cur_blk_idx][1]);
307 if (!(s->flags & CODEC_FLAG_GRAY)) {
308 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
309 v->block[v->cur_blk_idx][4]);
310 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
311 v->block[v->cur_blk_idx][5]);
314 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
315 v->block[v->cur_blk_idx][2]);
316 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
317 v->block[v->cur_blk_idx][3]);
320 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
321 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
322 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
323 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
324 v->block[v->left_blk_idx][0]);
325 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
326 v->block[v->left_blk_idx][1]);
327 if (!(s->flags & CODEC_FLAG_GRAY)) {
328 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
329 v->block[v->left_blk_idx][4]);
330 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
331 v->block[v->left_blk_idx][5]);
334 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
335 v->block[v->left_blk_idx][2]);
336 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
337 v->block[v->left_blk_idx][3]);
341 /** Do motion compensation over 1 macroblock
342 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
344 static void vc1_mc_1mv(VC1Context *v, int dir)
346 MpegEncContext *s = &v->s;
347 H264ChromaContext *h264chroma = &v->h264chroma;
348 uint8_t *srcY, *srcU, *srcV;
349 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
350 int v_edge_pos = s->v_edge_pos >> v->field_mode;
352 uint8_t (*luty)[256], (*lutuv)[256];
355 if ((!v->field_mode ||
356 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
357 !v->s.last_picture.f.data[0])
360 mx = s->mv[dir][0][0];
361 my = s->mv[dir][0][1];
363 // store motion vectors for further use in B frames
364 if (s->pict_type == AV_PICTURE_TYPE_P) {
365 for (i = 0; i < 4; i++) {
366 s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = mx;
367 s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = my;
371 uvmx = (mx + ((mx & 3) == 3)) >> 1;
372 uvmy = (my + ((my & 3) == 3)) >> 1;
373 v->luma_mv[s->mb_x][0] = uvmx;
374 v->luma_mv[s->mb_x][1] = uvmy;
377 v->cur_field_type != v->ref_field_type[dir]) {
378 my = my - 2 + 4 * v->cur_field_type;
379 uvmy = uvmy - 2 + 4 * v->cur_field_type;
382 // fastuvmc shall be ignored for interlaced frame picture
383 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
384 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
385 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
388 if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
389 srcY = s->current_picture.f.data[0];
390 srcU = s->current_picture.f.data[1];
391 srcV = s->current_picture.f.data[2];
393 lutuv = v->curr_lutuv;
394 use_ic = v->curr_use_ic;
396 srcY = s->last_picture.f.data[0];
397 srcU = s->last_picture.f.data[1];
398 srcV = s->last_picture.f.data[2];
400 lutuv = v->last_lutuv;
401 use_ic = v->last_use_ic;
404 srcY = s->next_picture.f.data[0];
405 srcU = s->next_picture.f.data[1];
406 srcV = s->next_picture.f.data[2];
408 lutuv = v->next_lutuv;
409 use_ic = v->next_use_ic;
412 if (!srcY || !srcU) {
413 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
417 src_x = s->mb_x * 16 + (mx >> 2);
418 src_y = s->mb_y * 16 + (my >> 2);
419 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
420 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
422 if (v->profile != PROFILE_ADVANCED) {
423 src_x = av_clip( src_x, -16, s->mb_width * 16);
424 src_y = av_clip( src_y, -16, s->mb_height * 16);
425 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
426 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
428 src_x = av_clip( src_x, -17, s->avctx->coded_width);
429 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
430 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
431 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
434 srcY += src_y * s->linesize + src_x;
435 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
436 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
438 if (v->field_mode && v->ref_field_type[dir]) {
439 srcY += s->current_picture_ptr->f.linesize[0];
440 srcU += s->current_picture_ptr->f.linesize[1];
441 srcV += s->current_picture_ptr->f.linesize[2];
444 /* for grayscale we should not try to read from unknown area */
445 if (s->flags & CODEC_FLAG_GRAY) {
446 srcU = s->edge_emu_buffer + 18 * s->linesize;
447 srcV = s->edge_emu_buffer + 18 * s->linesize;
450 if (v->rangeredfrm || use_ic
451 || s->h_edge_pos < 22 || v_edge_pos < 22
452 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
453 || (unsigned)(src_y - 1) > v_edge_pos - (my&3) - 16 - 3) {
454 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
456 srcY -= s->mspel * (1 + s->linesize);
457 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
458 17 + s->mspel * 2, 17 + s->mspel * 2,
459 src_x - s->mspel, src_y - s->mspel,
460 s->h_edge_pos, v_edge_pos);
461 srcY = s->edge_emu_buffer;
462 s->vdsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
463 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
464 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
465 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
468 /* if we deal with range reduction we need to scale source blocks */
469 if (v->rangeredfrm) {
474 for (j = 0; j < 17 + s->mspel * 2; j++) {
475 for (i = 0; i < 17 + s->mspel * 2; i++)
476 src[i] = ((src[i] - 128) >> 1) + 128;
481 for (j = 0; j < 9; j++) {
482 for (i = 0; i < 9; i++) {
483 src[i] = ((src[i] - 128) >> 1) + 128;
484 src2[i] = ((src2[i] - 128) >> 1) + 128;
486 src += s->uvlinesize;
487 src2 += s->uvlinesize;
490 /* if we deal with intensity compensation we need to scale source blocks */
496 for (j = 0; j < 17 + s->mspel * 2; j++) {
497 int f = v->field_mode ? v->ref_field_type[dir] : ((j + src_y - s->mspel) & 1) ;
498 for (i = 0; i < 17 + s->mspel * 2; i++)
499 src[i] = luty[f][src[i]];
504 for (j = 0; j < 9; j++) {
505 int f = v->field_mode ? v->ref_field_type[dir] : ((j + uvsrc_y) & 1);
506 for (i = 0; i < 9; i++) {
507 src[i] = lutuv[f][src[i]];
508 src2[i] = lutuv[f][src2[i]];
510 src += s->uvlinesize;
511 src2 += s->uvlinesize;
514 srcY += s->mspel * (1 + s->linesize);
518 dxy = ((my & 3) << 2) | (mx & 3);
519 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
520 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
521 srcY += s->linesize * 8;
522 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
523 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
524 } else { // hpel mc - always used for luma
525 dxy = (my & 2) | ((mx & 2) >> 1);
527 s->hdsp.put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
529 s->hdsp.put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
532 if (s->flags & CODEC_FLAG_GRAY) return;
533 /* Chroma MC always uses qpel bilinear */
534 uvmx = (uvmx & 3) << 1;
535 uvmy = (uvmy & 3) << 1;
537 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
538 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
540 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
541 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
545 static inline int median4(int a, int b, int c, int d)
548 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
549 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
551 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
552 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
556 /** Do motion compensation for 4-MV macroblock - luminance block
558 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
560 MpegEncContext *s = &v->s;
562 int dxy, mx, my, src_x, src_y;
564 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
565 int v_edge_pos = s->v_edge_pos >> v->field_mode;
566 uint8_t (*luty)[256];
569 if ((!v->field_mode ||
570 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
571 !v->s.last_picture.f.data[0])
574 mx = s->mv[dir][n][0];
575 my = s->mv[dir][n][1];
578 if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
579 srcY = s->current_picture.f.data[0];
581 use_ic = v->curr_use_ic;
583 srcY = s->last_picture.f.data[0];
585 use_ic = v->last_use_ic;
588 srcY = s->next_picture.f.data[0];
590 use_ic = v->next_use_ic;
594 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
599 if (v->cur_field_type != v->ref_field_type[dir])
600 my = my - 2 + 4 * v->cur_field_type;
603 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
604 int same_count = 0, opp_count = 0, k;
605 int chosen_mv[2][4][2], f;
607 for (k = 0; k < 4; k++) {
608 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
609 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
610 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
614 f = opp_count > same_count;
615 switch (f ? opp_count : same_count) {
617 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
618 chosen_mv[f][2][0], chosen_mv[f][3][0]);
619 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
620 chosen_mv[f][2][1], chosen_mv[f][3][1]);
623 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
624 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
627 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
628 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
633 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
634 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
635 for (k = 0; k < 4; k++)
636 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
639 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
641 int width = s->avctx->coded_width;
642 int height = s->avctx->coded_height >> 1;
643 if (s->pict_type == AV_PICTURE_TYPE_P) {
644 s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][0] = mx;
645 s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][1] = my;
647 qx = (s->mb_x * 16) + (mx >> 2);
648 qy = (s->mb_y * 8) + (my >> 3);
653 mx -= 4 * (qx - width);
656 else if (qy > height + 1)
657 my -= 8 * (qy - height - 1);
660 if ((v->fcm == ILACE_FRAME) && fieldmv)
661 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
663 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
665 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
667 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
669 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
671 if (v->profile != PROFILE_ADVANCED) {
672 src_x = av_clip(src_x, -16, s->mb_width * 16);
673 src_y = av_clip(src_y, -16, s->mb_height * 16);
675 src_x = av_clip(src_x, -17, s->avctx->coded_width);
676 if (v->fcm == ILACE_FRAME) {
678 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
680 src_y = av_clip(src_y, -18, s->avctx->coded_height);
682 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
686 srcY += src_y * s->linesize + src_x;
687 if (v->field_mode && v->ref_field_type[dir])
688 srcY += s->current_picture_ptr->f.linesize[0];
690 if (fieldmv && !(src_y & 1))
692 if (fieldmv && (src_y & 1) && src_y < 4)
694 if (v->rangeredfrm || use_ic
695 || s->h_edge_pos < 13 || v_edge_pos < 23
696 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
697 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
698 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
699 /* check emulate edge stride and offset */
700 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
701 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
702 src_x - s->mspel, src_y - (s->mspel << fieldmv),
703 s->h_edge_pos, v_edge_pos);
704 srcY = s->edge_emu_buffer;
705 /* if we deal with range reduction we need to scale source blocks */
706 if (v->rangeredfrm) {
711 for (j = 0; j < 9 + s->mspel * 2; j++) {
712 for (i = 0; i < 9 + s->mspel * 2; i++)
713 src[i] = ((src[i] - 128) >> 1) + 128;
714 src += s->linesize << fieldmv;
717 /* if we deal with intensity compensation we need to scale source blocks */
723 for (j = 0; j < 9 + s->mspel * 2; j++) {
724 int f = v->field_mode ? v->ref_field_type[dir] : (((j<<fieldmv)+src_y - (s->mspel << fieldmv)) & 1);
725 for (i = 0; i < 9 + s->mspel * 2; i++)
726 src[i] = luty[f][src[i]];
727 src += s->linesize << fieldmv;
730 srcY += s->mspel * (1 + (s->linesize << fieldmv));
734 dxy = ((my & 3) << 2) | (mx & 3);
736 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
738 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
739 } else { // hpel mc - always used for luma
740 dxy = (my & 2) | ((mx & 2) >> 1);
742 s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
744 s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
748 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
751 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
753 idx = ((a[3] != flag) << 3)
754 | ((a[2] != flag) << 2)
755 | ((a[1] != flag) << 1)
758 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
759 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
761 } else if (count[idx] == 1) {
764 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
765 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
768 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
769 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
772 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
773 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
776 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
777 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
780 } else if (count[idx] == 2) {
782 for (i = 0; i < 3; i++)
787 for (i = t1 + 1; i < 4; i++)
792 *tx = (mvx[t1] + mvx[t2]) / 2;
793 *ty = (mvy[t1] + mvy[t2]) / 2;
801 /** Do motion compensation for 4-MV macroblock - both chroma blocks
803 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
805 MpegEncContext *s = &v->s;
806 H264ChromaContext *h264chroma = &v->h264chroma;
807 uint8_t *srcU, *srcV;
808 int uvmx, uvmy, uvsrc_x, uvsrc_y;
809 int k, tx = 0, ty = 0;
810 int mvx[4], mvy[4], intra[4], mv_f[4];
812 int chroma_ref_type = v->cur_field_type;
813 int v_edge_pos = s->v_edge_pos >> v->field_mode;
814 uint8_t (*lutuv)[256];
817 if (!v->field_mode && !v->s.last_picture.f.data[0])
819 if (s->flags & CODEC_FLAG_GRAY)
822 for (k = 0; k < 4; k++) {
823 mvx[k] = s->mv[dir][k][0];
824 mvy[k] = s->mv[dir][k][1];
825 intra[k] = v->mb_type[0][s->block_index[k]];
827 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
830 /* calculate chroma MV vector from four luma MVs */
831 if (!v->field_mode || (v->field_mode && !v->numref)) {
832 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
833 chroma_ref_type = v->reffield;
835 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
836 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
837 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
838 return; //no need to do MC for intra blocks
842 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
844 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
846 chroma_ref_type = !v->cur_field_type;
848 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
850 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
851 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
852 uvmx = (tx + ((tx & 3) == 3)) >> 1;
853 uvmy = (ty + ((ty & 3) == 3)) >> 1;
855 v->luma_mv[s->mb_x][0] = uvmx;
856 v->luma_mv[s->mb_x][1] = uvmy;
859 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
860 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
862 // Field conversion bias
863 if (v->cur_field_type != chroma_ref_type)
864 uvmy += 2 - 4 * chroma_ref_type;
866 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
867 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
869 if (v->profile != PROFILE_ADVANCED) {
870 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
871 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
873 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
874 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
878 if (v->field_mode && (v->cur_field_type != chroma_ref_type) && v->second_field) {
879 srcU = s->current_picture.f.data[1];
880 srcV = s->current_picture.f.data[2];
881 lutuv = v->curr_lutuv;
882 use_ic = v->curr_use_ic;
884 srcU = s->last_picture.f.data[1];
885 srcV = s->last_picture.f.data[2];
886 lutuv = v->last_lutuv;
887 use_ic = v->last_use_ic;
890 srcU = s->next_picture.f.data[1];
891 srcV = s->next_picture.f.data[2];
892 lutuv = v->next_lutuv;
893 use_ic = v->next_use_ic;
897 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
901 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
902 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
905 if (chroma_ref_type) {
906 srcU += s->current_picture_ptr->f.linesize[1];
907 srcV += s->current_picture_ptr->f.linesize[2];
911 if (v->rangeredfrm || use_ic
912 || s->h_edge_pos < 18 || v_edge_pos < 18
913 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
914 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
915 s->vdsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
916 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
917 s->h_edge_pos >> 1, v_edge_pos >> 1);
918 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
919 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
920 s->h_edge_pos >> 1, v_edge_pos >> 1);
921 srcU = s->edge_emu_buffer;
922 srcV = s->edge_emu_buffer + 16;
924 /* if we deal with range reduction we need to scale source blocks */
925 if (v->rangeredfrm) {
931 for (j = 0; j < 9; j++) {
932 for (i = 0; i < 9; i++) {
933 src[i] = ((src[i] - 128) >> 1) + 128;
934 src2[i] = ((src2[i] - 128) >> 1) + 128;
936 src += s->uvlinesize;
937 src2 += s->uvlinesize;
940 /* if we deal with intensity compensation we need to scale source blocks */
947 for (j = 0; j < 9; j++) {
948 int f = v->field_mode ? chroma_ref_type : ((j + uvsrc_y) & 1);
949 for (i = 0; i < 9; i++) {
950 src[i] = lutuv[f][src[i]];
951 src2[i] = lutuv[f][src2[i]];
953 src += s->uvlinesize;
954 src2 += s->uvlinesize;
959 /* Chroma MC always uses qpel bilinear */
960 uvmx = (uvmx & 3) << 1;
961 uvmy = (uvmy & 3) << 1;
963 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
964 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
966 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
967 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
971 /** Do motion compensation for 4-MV interlaced frame chroma macroblock (both U and V)
973 static void vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)
975 MpegEncContext *s = &v->s;
976 H264ChromaContext *h264chroma = &v->h264chroma;
977 uint8_t *srcU, *srcV;
978 int uvsrc_x, uvsrc_y;
979 int uvmx_field[4], uvmy_field[4];
981 int fieldmv = v->blk_mv_type[s->block_index[0]];
982 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
983 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
984 int v_edge_pos = s->v_edge_pos >> 1;
986 uint8_t (*lutuv)[256];
988 if (s->flags & CODEC_FLAG_GRAY)
991 for (i = 0; i < 4; i++) {
992 int d = i < 2 ? dir: dir2;
994 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
997 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
999 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
1002 for (i = 0; i < 4; i++) {
1003 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
1004 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
1005 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
1006 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
1007 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1008 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1009 if (i < 2 ? dir : dir2) {
1010 srcU = s->next_picture.f.data[1];
1011 srcV = s->next_picture.f.data[2];
1012 lutuv = v->next_lutuv;
1013 use_ic = v->next_use_ic;
1015 srcU = s->last_picture.f.data[1];
1016 srcV = s->last_picture.f.data[2];
1017 lutuv = v->last_lutuv;
1018 use_ic = v->last_use_ic;
1022 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1023 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1024 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
1025 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
1027 if (fieldmv && !(uvsrc_y & 1))
1028 v_edge_pos = (s->v_edge_pos >> 1) - 1;
1030 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
1033 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
1034 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
1035 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
1036 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
1037 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1038 s->h_edge_pos >> 1, v_edge_pos);
1039 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
1040 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1041 s->h_edge_pos >> 1, v_edge_pos);
1042 srcU = s->edge_emu_buffer;
1043 srcV = s->edge_emu_buffer + 16;
1045 /* if we deal with intensity compensation we need to scale source blocks */
1048 uint8_t *src, *src2;
1052 for (j = 0; j < 5; j++) {
1053 int f = (uvsrc_y + (j << fieldmv)) & 1;
1054 for (i = 0; i < 5; i++) {
1055 src[i] = lutuv[f][src[i]];
1056 src2[i] = lutuv[f][src2[i]];
1058 src += s->uvlinesize << fieldmv;
1059 src2 += s->uvlinesize << fieldmv;
1065 h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1066 h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1068 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]);
1069 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]);
1073 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1074 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1076 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]);
1077 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]);
1083 /***********************************************************************/
1085 * @name VC-1 Block-level functions
1086 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1092 * @brief Get macroblock-level quantizer scale
1094 #define GET_MQUANT() \
1095 if (v->dquantfrm) { \
1097 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1098 if (v->dqbilevel) { \
1099 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1101 mqdiff = get_bits(gb, 3); \
1103 mquant = v->pq + mqdiff; \
1105 mquant = get_bits(gb, 5); \
1108 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1109 edges = 1 << v->dqsbedge; \
1110 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1111 edges = (3 << v->dqsbedge) % 15; \
1112 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1114 if ((edges&1) && !s->mb_x) \
1115 mquant = v->altpq; \
1116 if ((edges&2) && s->first_slice_line) \
1117 mquant = v->altpq; \
1118 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1119 mquant = v->altpq; \
1120 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1121 mquant = v->altpq; \
1122 if (!mquant || mquant > 31) { \
1123 av_log(v->s.avctx, AV_LOG_ERROR, \
1124 "Overriding invalid mquant %d\n", mquant); \
1130 * @def GET_MVDATA(_dmv_x, _dmv_y)
1131 * @brief Get MV differentials
1132 * @see MVDATA decoding from 8.3.5.2, p(1)20
1133 * @param _dmv_x Horizontal differential for decoded MV
1134 * @param _dmv_y Vertical differential for decoded MV
1136 #define GET_MVDATA(_dmv_x, _dmv_y) \
1137 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1138 VC1_MV_DIFF_VLC_BITS, 2); \
1140 mb_has_coeffs = 1; \
1143 mb_has_coeffs = 0; \
1146 _dmv_x = _dmv_y = 0; \
1147 } else if (index == 35) { \
1148 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1149 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1150 } else if (index == 36) { \
1155 index1 = index % 6; \
1156 if (!s->quarter_sample && index1 == 5) val = 1; \
1158 if (size_table[index1] - val > 0) \
1159 val = get_bits(gb, size_table[index1] - val); \
1161 sign = 0 - (val&1); \
1162 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1164 index1 = index / 6; \
1165 if (!s->quarter_sample && index1 == 5) val = 1; \
1167 if (size_table[index1] - val > 0) \
1168 val = get_bits(gb, size_table[index1] - val); \
1170 sign = 0 - (val & 1); \
1171 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1174 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1175 int *dmv_y, int *pred_flag)
1178 int extend_x = 0, extend_y = 0;
1179 GetBitContext *gb = &v->s.gb;
1182 const int* offs_tab;
1185 bits = VC1_2REF_MVDATA_VLC_BITS;
1188 bits = VC1_1REF_MVDATA_VLC_BITS;
1191 switch (v->dmvrange) {
1199 extend_x = extend_y = 1;
1202 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1204 *dmv_x = get_bits(gb, v->k_x);
1205 *dmv_y = get_bits(gb, v->k_y);
1208 *pred_flag = *dmv_y & 1;
1209 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1211 *dmv_y = (*dmv_y + (*dmv_y & 1)) >> 1;
1216 av_assert0(index < esc);
1218 offs_tab = offset_table2;
1220 offs_tab = offset_table1;
1221 index1 = (index + 1) % 9;
1223 val = get_bits(gb, index1 + extend_x);
1224 sign = 0 -(val & 1);
1225 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1229 offs_tab = offset_table2;
1231 offs_tab = offset_table1;
1232 index1 = (index + 1) / 9;
1233 if (index1 > v->numref) {
1234 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1235 sign = 0 - (val & 1);
1236 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1239 if (v->numref && pred_flag)
1240 *pred_flag = index1 & 1;
1244 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1246 int scaledvalue, refdist;
1247 int scalesame1, scalesame2;
1248 int scalezone1_x, zone1offset_x;
1249 int table_index = dir ^ v->second_field;
1251 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1252 refdist = v->refdist;
1254 refdist = dir ? v->brfd : v->frfd;
1257 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1258 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1259 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1260 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1265 if (FFABS(n) < scalezone1_x)
1266 scaledvalue = (n * scalesame1) >> 8;
1269 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1271 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1274 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1277 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1279 int scaledvalue, refdist;
1280 int scalesame1, scalesame2;
1281 int scalezone1_y, zone1offset_y;
1282 int table_index = dir ^ v->second_field;
1284 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1285 refdist = v->refdist;
1287 refdist = dir ? v->brfd : v->frfd;
1290 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1291 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1292 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1293 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1298 if (FFABS(n) < scalezone1_y)
1299 scaledvalue = (n * scalesame1) >> 8;
1302 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1304 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1308 if (v->cur_field_type && !v->ref_field_type[dir])
1309 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1311 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1314 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1316 int scalezone1_x, zone1offset_x;
1317 int scaleopp1, scaleopp2, brfd;
1320 brfd = FFMIN(v->brfd, 3);
1321 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1322 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1323 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1324 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1329 if (FFABS(n) < scalezone1_x)
1330 scaledvalue = (n * scaleopp1) >> 8;
1333 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1335 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1338 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1341 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1343 int scalezone1_y, zone1offset_y;
1344 int scaleopp1, scaleopp2, brfd;
1347 brfd = FFMIN(v->brfd, 3);
1348 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1349 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1350 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1351 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1356 if (FFABS(n) < scalezone1_y)
1357 scaledvalue = (n * scaleopp1) >> 8;
1360 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1362 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1365 if (v->cur_field_type && !v->ref_field_type[dir]) {
1366 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1368 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1372 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1375 int brfd, scalesame;
1376 int hpel = 1 - v->s.quarter_sample;
1379 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1381 n = scaleforsame_y(v, i, n, dir) << hpel;
1383 n = scaleforsame_x(v, n, dir) << hpel;
1386 brfd = FFMIN(v->brfd, 3);
1387 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1389 n = (n * scalesame >> 8) << hpel;
1393 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1396 int refdist, scaleopp;
1397 int hpel = 1 - v->s.quarter_sample;
1400 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1402 n = scaleforopp_y(v, n, dir) << hpel;
1404 n = scaleforopp_x(v, n) << hpel;
1407 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1408 refdist = FFMIN(v->refdist, 3);
1410 refdist = dir ? v->brfd : v->frfd;
1411 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1413 n = (n * scaleopp >> 8) << hpel;
1417 /** Predict and set motion vector
1419 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1420 int mv1, int r_x, int r_y, uint8_t* is_intra,
1421 int pred_flag, int dir)
1423 MpegEncContext *s = &v->s;
1424 int xy, wrap, off = 0;
1428 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1429 int opposite, a_f, b_f, c_f;
1430 int16_t field_predA[2];
1431 int16_t field_predB[2];
1432 int16_t field_predC[2];
1433 int a_valid, b_valid, c_valid;
1434 int hybridmv_thresh, y_bias = 0;
1436 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1437 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1441 /* scale MV difference to be quad-pel */
1442 dmv_x <<= 1 - s->quarter_sample;
1443 dmv_y <<= 1 - s->quarter_sample;
1445 wrap = s->b8_stride;
1446 xy = s->block_index[n];
1449 s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
1450 s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
1451 s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
1452 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
1453 if (mv1) { /* duplicate motion data for 1-MV block */
1454 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1455 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1456 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1457 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1458 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1459 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1460 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1461 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1462 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1463 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1464 s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1465 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1466 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1471 C = s->current_picture.motion_val[dir][xy - 1 + v->blocks_off];
1472 A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
1474 if (v->field_mode && mixedmv_pic)
1475 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1477 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1479 //in 4-MV mode different blocks have different B predictor position
1482 off = (s->mb_x > 0) ? -1 : 1;
1485 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1494 B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
1496 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1497 b_valid = a_valid && (s->mb_width > 1);
1498 c_valid = s->mb_x || (n == 1 || n == 3);
1499 if (v->field_mode) {
1500 a_valid = a_valid && !is_intra[xy - wrap];
1501 b_valid = b_valid && !is_intra[xy - wrap + off];
1502 c_valid = c_valid && !is_intra[xy - 1];
1506 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1507 num_oppfield += a_f;
1508 num_samefield += 1 - a_f;
1509 field_predA[0] = A[0];
1510 field_predA[1] = A[1];
1512 field_predA[0] = field_predA[1] = 0;
1516 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1517 num_oppfield += b_f;
1518 num_samefield += 1 - b_f;
1519 field_predB[0] = B[0];
1520 field_predB[1] = B[1];
1522 field_predB[0] = field_predB[1] = 0;
1526 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1527 num_oppfield += c_f;
1528 num_samefield += 1 - c_f;
1529 field_predC[0] = C[0];
1530 field_predC[1] = C[1];
1532 field_predC[0] = field_predC[1] = 0;
1536 if (v->field_mode) {
1538 // REFFIELD determines if the last field or the second-last field is
1539 // to be used as reference
1540 opposite = 1 - v->reffield;
1542 if (num_samefield <= num_oppfield)
1543 opposite = 1 - pred_flag;
1545 opposite = pred_flag;
1550 if (a_valid && !a_f) {
1551 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1552 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1554 if (b_valid && !b_f) {
1555 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1556 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1558 if (c_valid && !c_f) {
1559 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1560 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1562 v->mv_f[dir][xy + v->blocks_off] = 1;
1563 v->ref_field_type[dir] = !v->cur_field_type;
1565 if (a_valid && a_f) {
1566 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1567 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1569 if (b_valid && b_f) {
1570 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1571 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1573 if (c_valid && c_f) {
1574 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1575 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1577 v->mv_f[dir][xy + v->blocks_off] = 0;
1578 v->ref_field_type[dir] = v->cur_field_type;
1582 px = field_predA[0];
1583 py = field_predA[1];
1584 } else if (c_valid) {
1585 px = field_predC[0];
1586 py = field_predC[1];
1587 } else if (b_valid) {
1588 px = field_predB[0];
1589 py = field_predB[1];
1595 if (num_samefield + num_oppfield > 1) {
1596 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1597 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1600 /* Pullback MV as specified in 8.3.5.3.4 */
1601 if (!v->field_mode) {
1603 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1604 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1605 X = (s->mb_width << 6) - 4;
1606 Y = (s->mb_height << 6) - 4;
1608 if (qx + px < -60) px = -60 - qx;
1609 if (qy + py < -60) py = -60 - qy;
1611 if (qx + px < -28) px = -28 - qx;
1612 if (qy + py < -28) py = -28 - qy;
1614 if (qx + px > X) px = X - qx;
1615 if (qy + py > Y) py = Y - qy;
1618 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1619 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1620 hybridmv_thresh = 32;
1621 if (a_valid && c_valid) {
1622 if (is_intra[xy - wrap])
1623 sum = FFABS(px) + FFABS(py);
1625 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1626 if (sum > hybridmv_thresh) {
1627 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1628 px = field_predA[0];
1629 py = field_predA[1];
1631 px = field_predC[0];
1632 py = field_predC[1];
1635 if (is_intra[xy - 1])
1636 sum = FFABS(px) + FFABS(py);
1638 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1639 if (sum > hybridmv_thresh) {
1640 if (get_bits1(&s->gb)) {
1641 px = field_predA[0];
1642 py = field_predA[1];
1644 px = field_predC[0];
1645 py = field_predC[1];
1652 if (v->field_mode && v->numref)
1654 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1656 /* store MV using signed modulus of MV range defined in 4.11 */
1657 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;
1658 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;
1659 if (mv1) { /* duplicate motion data for 1-MV block */
1660 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1661 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1662 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1663 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1664 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1665 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1666 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1667 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];
1671 /** Predict and set motion vector for interlaced frame picture MBs
1673 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1674 int mvn, int r_x, int r_y, uint8_t* is_intra, int dir)
1676 MpegEncContext *s = &v->s;
1677 int xy, wrap, off = 0;
1678 int A[2], B[2], C[2];
1680 int a_valid = 0, b_valid = 0, c_valid = 0;
1681 int field_a, field_b, field_c; // 0: same, 1: opposit
1682 int total_valid, num_samefield, num_oppfield;
1683 int pos_c, pos_b, n_adj;
1685 wrap = s->b8_stride;
1686 xy = s->block_index[n];
1689 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1690 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1691 s->current_picture.motion_val[1][xy][0] = 0;
1692 s->current_picture.motion_val[1][xy][1] = 0;
1693 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1694 s->current_picture.motion_val[0][xy + 1][0] = 0;
1695 s->current_picture.motion_val[0][xy + 1][1] = 0;
1696 s->current_picture.motion_val[0][xy + wrap][0] = 0;
1697 s->current_picture.motion_val[0][xy + wrap][1] = 0;
1698 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1699 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1700 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1701 s->current_picture.motion_val[1][xy + 1][0] = 0;
1702 s->current_picture.motion_val[1][xy + 1][1] = 0;
1703 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1704 s->current_picture.motion_val[1][xy + wrap][1] = 0;
1705 s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
1706 s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
1711 off = ((n == 0) || (n == 1)) ? 1 : -1;
1713 if (s->mb_x || (n == 1) || (n == 3)) {
1714 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1715 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1716 A[0] = s->current_picture.motion_val[dir][xy - 1][0];
1717 A[1] = s->current_picture.motion_val[dir][xy - 1][1];
1719 } else { // current block has frame mv and cand. has field MV (so average)
1720 A[0] = (s->current_picture.motion_val[dir][xy - 1][0]
1721 + s->current_picture.motion_val[dir][xy - 1 + off * wrap][0] + 1) >> 1;
1722 A[1] = (s->current_picture.motion_val[dir][xy - 1][1]
1723 + s->current_picture.motion_val[dir][xy - 1 + off * wrap][1] + 1) >> 1;
1726 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1732 /* Predict B and C */
1733 B[0] = B[1] = C[0] = C[1] = 0;
1734 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1735 if (!s->first_slice_line) {
1736 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1739 pos_b = s->block_index[n_adj] - 2 * wrap;
1740 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1741 n_adj = (n & 2) | (n & 1);
1743 B[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][0];
1744 B[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][1];
1745 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1746 B[0] = (B[0] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1747 B[1] = (B[1] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1750 if (s->mb_width > 1) {
1751 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1754 pos_c = s->block_index[2] - 2 * wrap + 2;
1755 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1758 C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][0];
1759 C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][1];
1760 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1761 C[0] = (1 + C[0] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1762 C[1] = (1 + C[1] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1764 if (s->mb_x == s->mb_width - 1) {
1765 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1768 pos_c = s->block_index[3] - 2 * wrap - 2;
1769 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1772 C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][0];
1773 C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][1];
1774 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1775 C[0] = (1 + C[0] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1776 C[1] = (1 + C[1] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1785 pos_b = s->block_index[1];
1787 B[0] = s->current_picture.motion_val[dir][pos_b][0];
1788 B[1] = s->current_picture.motion_val[dir][pos_b][1];
1789 pos_c = s->block_index[0];
1791 C[0] = s->current_picture.motion_val[dir][pos_c][0];
1792 C[1] = s->current_picture.motion_val[dir][pos_c][1];
1795 total_valid = a_valid + b_valid + c_valid;
1796 // check if predictor A is out of bounds
1797 if (!s->mb_x && !(n == 1 || n == 3)) {
1800 // check if predictor B is out of bounds
1801 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1802 B[0] = B[1] = C[0] = C[1] = 0;
1804 if (!v->blk_mv_type[xy]) {
1805 if (s->mb_width == 1) {
1809 if (total_valid >= 2) {
1810 px = mid_pred(A[0], B[0], C[0]);
1811 py = mid_pred(A[1], B[1], C[1]);
1812 } else if (total_valid) {
1813 if (a_valid) { px = A[0]; py = A[1]; }
1814 else if (b_valid) { px = B[0]; py = B[1]; }
1815 else if (c_valid) { px = C[0]; py = C[1]; }
1821 field_a = (A[1] & 4) ? 1 : 0;
1825 field_b = (B[1] & 4) ? 1 : 0;
1829 field_c = (C[1] & 4) ? 1 : 0;
1833 num_oppfield = field_a + field_b + field_c;
1834 num_samefield = total_valid - num_oppfield;
1835 if (total_valid == 3) {
1836 if ((num_samefield == 3) || (num_oppfield == 3)) {
1837 px = mid_pred(A[0], B[0], C[0]);
1838 py = mid_pred(A[1], B[1], C[1]);
1839 } else if (num_samefield >= num_oppfield) {
1840 /* take one MV from same field set depending on priority
1841 the check for B may not be necessary */
1842 px = !field_a ? A[0] : B[0];
1843 py = !field_a ? A[1] : B[1];
1845 px = field_a ? A[0] : B[0];
1846 py = field_a ? A[1] : B[1];
1848 } else if (total_valid == 2) {
1849 if (num_samefield >= num_oppfield) {
1850 if (!field_a && a_valid) {
1853 } else if (!field_b && b_valid) {
1856 } else /*if (c_valid)*/ {
1857 av_assert1(c_valid);
1860 } /*else px = py = 0;*/
1862 if (field_a && a_valid) {
1865 } else /*if (field_b && b_valid)*/ {
1866 av_assert1(field_b && b_valid);
1869 } /*else if (c_valid) {
1874 } else if (total_valid == 1) {
1875 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1876 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1880 /* store MV using signed modulus of MV range defined in 4.11 */
1881 s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1882 s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1883 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1884 s->current_picture.motion_val[dir][xy + 1 ][0] = s->current_picture.motion_val[dir][xy][0];
1885 s->current_picture.motion_val[dir][xy + 1 ][1] = s->current_picture.motion_val[dir][xy][1];
1886 s->current_picture.motion_val[dir][xy + wrap ][0] = s->current_picture.motion_val[dir][xy][0];
1887 s->current_picture.motion_val[dir][xy + wrap ][1] = s->current_picture.motion_val[dir][xy][1];
1888 s->current_picture.motion_val[dir][xy + wrap + 1][0] = s->current_picture.motion_val[dir][xy][0];
1889 s->current_picture.motion_val[dir][xy + wrap + 1][1] = s->current_picture.motion_val[dir][xy][1];
1890 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1891 s->current_picture.motion_val[dir][xy + 1][0] = s->current_picture.motion_val[dir][xy][0];
1892 s->current_picture.motion_val[dir][xy + 1][1] = s->current_picture.motion_val[dir][xy][1];
1893 s->mv[dir][n + 1][0] = s->mv[dir][n][0];
1894 s->mv[dir][n + 1][1] = s->mv[dir][n][1];
1898 /** Motion compensation for direct or interpolated blocks in B-frames
1900 static void vc1_interp_mc(VC1Context *v)
1902 MpegEncContext *s = &v->s;
1903 H264ChromaContext *h264chroma = &v->h264chroma;
1904 uint8_t *srcY, *srcU, *srcV;
1905 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1907 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1908 int use_ic = v->next_use_ic;
1910 if (!v->field_mode && !v->s.next_picture.f.data[0])
1913 mx = s->mv[1][0][0];
1914 my = s->mv[1][0][1];
1915 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1916 uvmy = (my + ((my & 3) == 3)) >> 1;
1917 if (v->field_mode) {
1918 if (v->cur_field_type != v->ref_field_type[1])
1919 my = my - 2 + 4 * v->cur_field_type;
1920 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1923 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1924 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1926 srcY = s->next_picture.f.data[0];
1927 srcU = s->next_picture.f.data[1];
1928 srcV = s->next_picture.f.data[2];
1930 src_x = s->mb_x * 16 + (mx >> 2);
1931 src_y = s->mb_y * 16 + (my >> 2);
1932 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1933 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1935 if (v->profile != PROFILE_ADVANCED) {
1936 src_x = av_clip( src_x, -16, s->mb_width * 16);
1937 src_y = av_clip( src_y, -16, s->mb_height * 16);
1938 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1939 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1941 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1942 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1943 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1944 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1947 srcY += src_y * s->linesize + src_x;
1948 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1949 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1951 if (v->field_mode && v->ref_field_type[1]) {
1952 srcY += s->current_picture_ptr->f.linesize[0];
1953 srcU += s->current_picture_ptr->f.linesize[1];
1954 srcV += s->current_picture_ptr->f.linesize[2];
1957 /* for grayscale we should not try to read from unknown area */
1958 if (s->flags & CODEC_FLAG_GRAY) {
1959 srcU = s->edge_emu_buffer + 18 * s->linesize;
1960 srcV = s->edge_emu_buffer + 18 * s->linesize;
1963 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22 || use_ic
1964 || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1965 || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1966 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1968 srcY -= s->mspel * (1 + s->linesize);
1969 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1970 17 + s->mspel * 2, 17 + s->mspel * 2,
1971 src_x - s->mspel, src_y - s->mspel,
1972 s->h_edge_pos, v_edge_pos);
1973 srcY = s->edge_emu_buffer;
1974 s->vdsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1975 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1976 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1977 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1980 /* if we deal with range reduction we need to scale source blocks */
1981 if (v->rangeredfrm) {
1983 uint8_t *src, *src2;
1986 for (j = 0; j < 17 + s->mspel * 2; j++) {
1987 for (i = 0; i < 17 + s->mspel * 2; i++)
1988 src[i] = ((src[i] - 128) >> 1) + 128;
1993 for (j = 0; j < 9; j++) {
1994 for (i = 0; i < 9; i++) {
1995 src[i] = ((src[i] - 128) >> 1) + 128;
1996 src2[i] = ((src2[i] - 128) >> 1) + 128;
1998 src += s->uvlinesize;
1999 src2 += s->uvlinesize;
2004 uint8_t (*luty )[256] = v->next_luty;
2005 uint8_t (*lutuv)[256] = v->next_lutuv;
2007 uint8_t *src, *src2;
2010 for (j = 0; j < 17 + s->mspel * 2; j++) {
2011 int f = v->field_mode ? v->ref_field_type[1] : ((j+src_y - s->mspel) & 1);
2012 for (i = 0; i < 17 + s->mspel * 2; i++)
2013 src[i] = luty[f][src[i]];
2018 for (j = 0; j < 9; j++) {
2019 int f = v->field_mode ? v->ref_field_type[1] : ((j+uvsrc_y) & 1);
2020 for (i = 0; i < 9; i++) {
2021 src[i] = lutuv[f][src[i]];
2022 src2[i] = lutuv[f][src2[i]];
2024 src += s->uvlinesize;
2025 src2 += s->uvlinesize;
2028 srcY += s->mspel * (1 + s->linesize);
2035 dxy = ((my & 3) << 2) | (mx & 3);
2036 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
2037 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
2038 srcY += s->linesize * 8;
2039 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
2040 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
2042 dxy = (my & 2) | ((mx & 2) >> 1);
2045 s->hdsp.avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
2047 s->hdsp.avg_no_rnd_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, 16);
2050 if (s->flags & CODEC_FLAG_GRAY) return;
2051 /* Chroma MC always uses qpel blilinear */
2052 uvmx = (uvmx & 3) << 1;
2053 uvmy = (uvmy & 3) << 1;
2055 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2056 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2058 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2059 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2063 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2067 #if B_FRACTION_DEN==256
2071 return 2 * ((value * n + 255) >> 9);
2072 return (value * n + 128) >> 8;
2075 n -= B_FRACTION_DEN;
2077 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2078 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2082 /** Reconstruct motion vector for B-frame and do motion compensation
2084 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2085 int direct, int mode)
2092 if (mode == BMV_TYPE_INTERPOLATED) {
2098 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2101 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2102 int direct, int mvtype)
2104 MpegEncContext *s = &v->s;
2105 int xy, wrap, off = 0;
2110 const uint8_t *is_intra = v->mb_type[0];
2114 /* scale MV difference to be quad-pel */
2115 dmv_x[0] <<= 1 - s->quarter_sample;
2116 dmv_y[0] <<= 1 - s->quarter_sample;
2117 dmv_x[1] <<= 1 - s->quarter_sample;
2118 dmv_y[1] <<= 1 - s->quarter_sample;
2120 wrap = s->b8_stride;
2121 xy = s->block_index[0];
2124 s->current_picture.motion_val[0][xy + v->blocks_off][0] =
2125 s->current_picture.motion_val[0][xy + v->blocks_off][1] =
2126 s->current_picture.motion_val[1][xy + v->blocks_off][0] =
2127 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
2130 if (!v->field_mode) {
2131 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2132 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2133 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2134 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2136 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2137 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));
2138 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));
2139 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));
2140 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));
2143 s->current_picture.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2144 s->current_picture.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2145 s->current_picture.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2146 s->current_picture.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2150 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2151 C = s->current_picture.motion_val[0][xy - 2];
2152 A = s->current_picture.motion_val[0][xy - wrap * 2];
2153 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2154 B = s->current_picture.motion_val[0][xy - wrap * 2 + off];
2156 if (!s->mb_x) C[0] = C[1] = 0;
2157 if (!s->first_slice_line) { // predictor A is not out of bounds
2158 if (s->mb_width == 1) {
2162 px = mid_pred(A[0], B[0], C[0]);
2163 py = mid_pred(A[1], B[1], C[1]);
2165 } else if (s->mb_x) { // predictor C is not out of bounds
2171 /* Pullback MV as specified in 8.3.5.3.4 */
2174 if (v->profile < PROFILE_ADVANCED) {
2175 qx = (s->mb_x << 5);
2176 qy = (s->mb_y << 5);
2177 X = (s->mb_width << 5) - 4;
2178 Y = (s->mb_height << 5) - 4;
2179 if (qx + px < -28) px = -28 - qx;
2180 if (qy + py < -28) py = -28 - qy;
2181 if (qx + px > X) px = X - qx;
2182 if (qy + py > Y) py = Y - qy;
2184 qx = (s->mb_x << 6);
2185 qy = (s->mb_y << 6);
2186 X = (s->mb_width << 6) - 4;
2187 Y = (s->mb_height << 6) - 4;
2188 if (qx + px < -60) px = -60 - qx;
2189 if (qy + py < -60) py = -60 - qy;
2190 if (qx + px > X) px = X - qx;
2191 if (qy + py > Y) py = Y - qy;
2194 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2195 if (0 && !s->first_slice_line && s->mb_x) {
2196 if (is_intra[xy - wrap])
2197 sum = FFABS(px) + FFABS(py);
2199 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2201 if (get_bits1(&s->gb)) {
2209 if (is_intra[xy - 2])
2210 sum = FFABS(px) + FFABS(py);
2212 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2214 if (get_bits1(&s->gb)) {
2224 /* store MV using signed modulus of MV range defined in 4.11 */
2225 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2226 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2228 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2229 C = s->current_picture.motion_val[1][xy - 2];
2230 A = s->current_picture.motion_val[1][xy - wrap * 2];
2231 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2232 B = s->current_picture.motion_val[1][xy - wrap * 2 + off];
2236 if (!s->first_slice_line) { // predictor A is not out of bounds
2237 if (s->mb_width == 1) {
2241 px = mid_pred(A[0], B[0], C[0]);
2242 py = mid_pred(A[1], B[1], C[1]);
2244 } else if (s->mb_x) { // predictor C is not out of bounds
2250 /* Pullback MV as specified in 8.3.5.3.4 */
2253 if (v->profile < PROFILE_ADVANCED) {
2254 qx = (s->mb_x << 5);
2255 qy = (s->mb_y << 5);
2256 X = (s->mb_width << 5) - 4;
2257 Y = (s->mb_height << 5) - 4;
2258 if (qx + px < -28) px = -28 - qx;
2259 if (qy + py < -28) py = -28 - qy;
2260 if (qx + px > X) px = X - qx;
2261 if (qy + py > Y) py = Y - qy;
2263 qx = (s->mb_x << 6);
2264 qy = (s->mb_y << 6);
2265 X = (s->mb_width << 6) - 4;
2266 Y = (s->mb_height << 6) - 4;
2267 if (qx + px < -60) px = -60 - qx;
2268 if (qy + py < -60) py = -60 - qy;
2269 if (qx + px > X) px = X - qx;
2270 if (qy + py > Y) py = Y - qy;
2273 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2274 if (0 && !s->first_slice_line && s->mb_x) {
2275 if (is_intra[xy - wrap])
2276 sum = FFABS(px) + FFABS(py);
2278 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2280 if (get_bits1(&s->gb)) {
2288 if (is_intra[xy - 2])
2289 sum = FFABS(px) + FFABS(py);
2291 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2293 if (get_bits1(&s->gb)) {
2303 /* store MV using signed modulus of MV range defined in 4.11 */
2305 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2306 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2308 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2309 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2310 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2311 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2314 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2316 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2317 MpegEncContext *s = &v->s;
2318 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2320 if (v->bmvtype == BMV_TYPE_DIRECT) {
2321 int total_opp, k, f;
2322 if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2323 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2324 v->bfraction, 0, s->quarter_sample);
2325 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2326 v->bfraction, 0, s->quarter_sample);
2327 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2328 v->bfraction, 1, s->quarter_sample);
2329 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2330 v->bfraction, 1, s->quarter_sample);
2332 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2333 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2334 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2335 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2336 f = (total_opp > 2) ? 1 : 0;
2338 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2339 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2342 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2343 for (k = 0; k < 4; k++) {
2344 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2345 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2346 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2347 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2348 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2349 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2353 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2354 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);
2355 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);
2358 if (dir) { // backward
2359 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);
2360 if (n == 3 || mv1) {
2361 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2364 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);
2365 if (n == 3 || mv1) {
2366 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2371 /** Get predicted DC value for I-frames only
2372 * prediction dir: left=0, top=1
2373 * @param s MpegEncContext
2374 * @param overlap flag indicating that overlap filtering is used
2375 * @param pq integer part of picture quantizer
2376 * @param[in] n block index in the current MB
2377 * @param dc_val_ptr Pointer to DC predictor
2378 * @param dir_ptr Prediction direction for use in AC prediction
2380 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2381 int16_t **dc_val_ptr, int *dir_ptr)
2383 int a, b, c, wrap, pred, scale;
2385 static const uint16_t dcpred[32] = {
2386 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2387 114, 102, 93, 85, 79, 73, 68, 64,
2388 60, 57, 54, 51, 49, 47, 45, 43,
2389 41, 39, 38, 37, 35, 34, 33
2392 /* find prediction - wmv3_dc_scale always used here in fact */
2393 if (n < 4) scale = s->y_dc_scale;
2394 else scale = s->c_dc_scale;
2396 wrap = s->block_wrap[n];
2397 dc_val = s->dc_val[0] + s->block_index[n];
2403 b = dc_val[ - 1 - wrap];
2404 a = dc_val[ - wrap];
2406 if (pq < 9 || !overlap) {
2407 /* Set outer values */
2408 if (s->first_slice_line && (n != 2 && n != 3))
2409 b = a = dcpred[scale];
2410 if (s->mb_x == 0 && (n != 1 && n != 3))
2411 b = c = dcpred[scale];
2413 /* Set outer values */
2414 if (s->first_slice_line && (n != 2 && n != 3))
2416 if (s->mb_x == 0 && (n != 1 && n != 3))
2420 if (abs(a - b) <= abs(b - c)) {
2422 *dir_ptr = 1; // left
2425 *dir_ptr = 0; // top
2428 /* update predictor */
2429 *dc_val_ptr = &dc_val[0];
2434 /** Get predicted DC value
2435 * prediction dir: left=0, top=1
2436 * @param s MpegEncContext
2437 * @param overlap flag indicating that overlap filtering is used
2438 * @param pq integer part of picture quantizer
2439 * @param[in] n block index in the current MB
2440 * @param a_avail flag indicating top block availability
2441 * @param c_avail flag indicating left block availability
2442 * @param dc_val_ptr Pointer to DC predictor
2443 * @param dir_ptr Prediction direction for use in AC prediction
2445 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2446 int a_avail, int c_avail,
2447 int16_t **dc_val_ptr, int *dir_ptr)
2449 int a, b, c, wrap, pred;
2451 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2455 wrap = s->block_wrap[n];
2456 dc_val = s->dc_val[0] + s->block_index[n];
2462 b = dc_val[ - 1 - wrap];
2463 a = dc_val[ - wrap];
2464 /* scale predictors if needed */
2465 q1 = s->current_picture.qscale_table[mb_pos];
2466 dqscale_index = s->y_dc_scale_table[q1] - 1;
2467 if (dqscale_index < 0)
2469 if (c_avail && (n != 1 && n != 3)) {
2470 q2 = s->current_picture.qscale_table[mb_pos - 1];
2472 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2474 if (a_avail && (n != 2 && n != 3)) {
2475 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2477 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2479 if (a_avail && c_avail && (n != 3)) {
2484 off -= s->mb_stride;
2485 q2 = s->current_picture.qscale_table[off];
2487 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2490 if (a_avail && c_avail) {
2491 if (abs(a - b) <= abs(b - c)) {
2493 *dir_ptr = 1; // left
2496 *dir_ptr = 0; // top
2498 } else if (a_avail) {
2500 *dir_ptr = 0; // top
2501 } else if (c_avail) {
2503 *dir_ptr = 1; // left
2506 *dir_ptr = 1; // left
2509 /* update predictor */
2510 *dc_val_ptr = &dc_val[0];
2514 /** @} */ // Block group
2517 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2518 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2522 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2523 uint8_t **coded_block_ptr)
2525 int xy, wrap, pred, a, b, c;
2527 xy = s->block_index[n];
2528 wrap = s->b8_stride;
2533 a = s->coded_block[xy - 1 ];
2534 b = s->coded_block[xy - 1 - wrap];
2535 c = s->coded_block[xy - wrap];
2544 *coded_block_ptr = &s->coded_block[xy];
2550 * Decode one AC coefficient
2551 * @param v The VC1 context
2552 * @param last Last coefficient
2553 * @param skip How much zero coefficients to skip
2554 * @param value Decoded AC coefficient value
2555 * @param codingset set of VLC to decode data
2558 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2559 int *value, int codingset)
2561 GetBitContext *gb = &v->s.gb;
2562 int index, escape, run = 0, level = 0, lst = 0;
2564 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2565 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2566 run = vc1_index_decode_table[codingset][index][0];
2567 level = vc1_index_decode_table[codingset][index][1];
2568 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2572 escape = decode210(gb);
2574 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2575 run = vc1_index_decode_table[codingset][index][0];
2576 level = vc1_index_decode_table[codingset][index][1];
2577 lst = index >= vc1_last_decode_table[codingset];
2580 level += vc1_last_delta_level_table[codingset][run];
2582 level += vc1_delta_level_table[codingset][run];
2585 run += vc1_last_delta_run_table[codingset][level] + 1;
2587 run += vc1_delta_run_table[codingset][level] + 1;
2593 lst = get_bits1(gb);
2594 if (v->s.esc3_level_length == 0) {
2595 if (v->pq < 8 || v->dquantfrm) { // table 59
2596 v->s.esc3_level_length = get_bits(gb, 3);
2597 if (!v->s.esc3_level_length)
2598 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2599 } else { // table 60
2600 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2602 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2604 run = get_bits(gb, v->s.esc3_run_length);
2605 sign = get_bits1(gb);
2606 level = get_bits(gb, v->s.esc3_level_length);
2617 /** Decode intra block in intra frames - should be faster than decode_intra_block
2618 * @param v VC1Context
2619 * @param block block to decode
2620 * @param[in] n subblock index
2621 * @param coded are AC coeffs present or not
2622 * @param codingset set of VLC to decode data
2624 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
2625 int coded, int codingset)
2627 GetBitContext *gb = &v->s.gb;
2628 MpegEncContext *s = &v->s;
2629 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2632 int16_t *ac_val, *ac_val2;
2635 /* Get DC differential */
2637 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2639 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2642 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2646 if (dcdiff == 119 /* ESC index value */) {
2647 /* TODO: Optimize */
2648 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2649 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2650 else dcdiff = get_bits(gb, 8);
2653 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2654 else if (v->pq == 2)
2655 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2662 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2665 /* Store the quantized DC coeff, used for prediction */
2667 block[0] = dcdiff * s->y_dc_scale;
2669 block[0] = dcdiff * s->c_dc_scale;
2680 int last = 0, skip, value;
2681 const uint8_t *zz_table;
2685 scale = v->pq * 2 + v->halfpq;
2689 zz_table = v->zz_8x8[2];
2691 zz_table = v->zz_8x8[3];
2693 zz_table = v->zz_8x8[1];
2695 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2697 if (dc_pred_dir) // left
2700 ac_val -= 16 * s->block_wrap[n];
2703 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2707 block[zz_table[i++]] = value;
2710 /* apply AC prediction if needed */
2712 if (dc_pred_dir) { // left
2713 for (k = 1; k < 8; k++)
2714 block[k << v->left_blk_sh] += ac_val[k];
2716 for (k = 1; k < 8; k++)
2717 block[k << v->top_blk_sh] += ac_val[k + 8];
2720 /* save AC coeffs for further prediction */
2721 for (k = 1; k < 8; k++) {
2722 ac_val2[k] = block[k << v->left_blk_sh];
2723 ac_val2[k + 8] = block[k << v->top_blk_sh];
2726 /* scale AC coeffs */
2727 for (k = 1; k < 64; k++)
2731 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2734 if (s->ac_pred) i = 63;
2740 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2744 scale = v->pq * 2 + v->halfpq;
2745 memset(ac_val2, 0, 16 * 2);
2746 if (dc_pred_dir) { // left
2749 memcpy(ac_val2, ac_val, 8 * 2);
2751 ac_val -= 16 * s->block_wrap[n];
2753 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2756 /* apply AC prediction if needed */
2758 if (dc_pred_dir) { //left
2759 for (k = 1; k < 8; k++) {
2760 block[k << v->left_blk_sh] = ac_val[k] * scale;
2761 if (!v->pquantizer && block[k << v->left_blk_sh])
2762 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2765 for (k = 1; k < 8; k++) {
2766 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2767 if (!v->pquantizer && block[k << v->top_blk_sh])
2768 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2774 s->block_last_index[n] = i;
2779 /** Decode intra block in intra frames - should be faster than decode_intra_block
2780 * @param v VC1Context
2781 * @param block block to decode
2782 * @param[in] n subblock number
2783 * @param coded are AC coeffs present or not
2784 * @param codingset set of VLC to decode data
2785 * @param mquant quantizer value for this macroblock
2787 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
2788 int coded, int codingset, int mquant)
2790 GetBitContext *gb = &v->s.gb;
2791 MpegEncContext *s = &v->s;
2792 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2794 int16_t *dc_val = NULL;
2795 int16_t *ac_val, *ac_val2;
2797 int a_avail = v->a_avail, c_avail = v->c_avail;
2798 int use_pred = s->ac_pred;
2801 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2803 /* Get DC differential */
2805 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2807 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2810 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2814 if (dcdiff == 119 /* ESC index value */) {
2815 /* TODO: Optimize */
2816 if (mquant == 1) dcdiff = get_bits(gb, 10);
2817 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2818 else dcdiff = get_bits(gb, 8);
2821 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2822 else if (mquant == 2)
2823 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2830 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2833 /* Store the quantized DC coeff, used for prediction */
2835 block[0] = dcdiff * s->y_dc_scale;
2837 block[0] = dcdiff * s->c_dc_scale;
2843 /* check if AC is needed at all */
2844 if (!a_avail && !c_avail)
2846 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2849 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2851 if (dc_pred_dir) // left
2854 ac_val -= 16 * s->block_wrap[n];
2856 q1 = s->current_picture.qscale_table[mb_pos];
2857 if ( dc_pred_dir && c_avail && mb_pos)
2858 q2 = s->current_picture.qscale_table[mb_pos - 1];
2859 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2860 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2861 if ( dc_pred_dir && n == 1)
2863 if (!dc_pred_dir && n == 2)
2869 int last = 0, skip, value;
2870 const uint8_t *zz_table;
2874 if (!use_pred && v->fcm == ILACE_FRAME) {
2875 zz_table = v->zzi_8x8;
2877 if (!dc_pred_dir) // top
2878 zz_table = v->zz_8x8[2];
2880 zz_table = v->zz_8x8[3];
2883 if (v->fcm != ILACE_FRAME)
2884 zz_table = v->zz_8x8[1];
2886 zz_table = v->zzi_8x8;
2890 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2894 block[zz_table[i++]] = value;
2897 /* apply AC prediction if needed */
2899 /* scale predictors if needed*/
2900 if (q2 && q1 != q2) {
2901 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2902 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2905 return AVERROR_INVALIDDATA;
2906 if (dc_pred_dir) { // left
2907 for (k = 1; k < 8; k++)
2908 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2910 for (k = 1; k < 8; k++)
2911 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2914 if (dc_pred_dir) { //left
2915 for (k = 1; k < 8; k++)
2916 block[k << v->left_blk_sh] += ac_val[k];
2918 for (k = 1; k < 8; k++)
2919 block[k << v->top_blk_sh] += ac_val[k + 8];
2923 /* save AC coeffs for further prediction */
2924 for (k = 1; k < 8; k++) {
2925 ac_val2[k ] = block[k << v->left_blk_sh];
2926 ac_val2[k + 8] = block[k << v->top_blk_sh];
2929 /* scale AC coeffs */
2930 for (k = 1; k < 64; k++)
2934 block[k] += (block[k] < 0) ? -mquant : mquant;
2937 if (use_pred) i = 63;
2938 } else { // no AC coeffs
2941 memset(ac_val2, 0, 16 * 2);
2942 if (dc_pred_dir) { // left
2944 memcpy(ac_val2, ac_val, 8 * 2);
2945 if (q2 && q1 != q2) {
2946 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2947 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2949 return AVERROR_INVALIDDATA;
2950 for (k = 1; k < 8; k++)
2951 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2956 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2957 if (q2 && q1 != q2) {
2958 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2959 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2961 return AVERROR_INVALIDDATA;
2962 for (k = 1; k < 8; k++)
2963 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2968 /* apply AC prediction if needed */
2970 if (dc_pred_dir) { // left
2971 for (k = 1; k < 8; k++) {
2972 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2973 if (!v->pquantizer && block[k << v->left_blk_sh])
2974 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2977 for (k = 1; k < 8; k++) {
2978 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2979 if (!v->pquantizer && block[k << v->top_blk_sh])
2980 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2986 s->block_last_index[n] = i;
2991 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2992 * @param v VC1Context
2993 * @param block block to decode
2994 * @param[in] n subblock index
2995 * @param coded are AC coeffs present or not
2996 * @param mquant block quantizer
2997 * @param codingset set of VLC to decode data
2999 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
3000 int coded, int mquant, int codingset)
3002 GetBitContext *gb = &v->s.gb;
3003 MpegEncContext *s = &v->s;
3004 int dc_pred_dir = 0; /* Direction of the DC prediction used */
3006 int16_t *dc_val = NULL;
3007 int16_t *ac_val, *ac_val2;
3009 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3010 int a_avail = v->a_avail, c_avail = v->c_avail;
3011 int use_pred = s->ac_pred;
3015 s->dsp.clear_block(block);
3017 /* XXX: Guard against dumb values of mquant */
3018 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
3020 /* Set DC scale - y and c use the same */
3021 s->y_dc_scale = s->y_dc_scale_table[mquant];
3022 s->c_dc_scale = s->c_dc_scale_table[mquant];
3024 /* Get DC differential */
3026 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3028 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3031 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3035 if (dcdiff == 119 /* ESC index value */) {
3036 /* TODO: Optimize */
3037 if (mquant == 1) dcdiff = get_bits(gb, 10);
3038 else if (mquant == 2) dcdiff = get_bits(gb, 9);
3039 else dcdiff = get_bits(gb, 8);
3042 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
3043 else if (mquant == 2)
3044 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
3051 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3054 /* Store the quantized DC coeff, used for prediction */
3057 block[0] = dcdiff * s->y_dc_scale;
3059 block[0] = dcdiff * s->c_dc_scale;
3065 /* check if AC is needed at all and adjust direction if needed */
3066 if (!a_avail) dc_pred_dir = 1;
3067 if (!c_avail) dc_pred_dir = 0;
3068 if (!a_avail && !c_avail) use_pred = 0;
3069 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3072 scale = mquant * 2 + v->halfpq;
3074 if (dc_pred_dir) //left
3077 ac_val -= 16 * s->block_wrap[n];
3079 q1 = s->current_picture.qscale_table[mb_pos];
3080 if (dc_pred_dir && c_avail && mb_pos)
3081 q2 = s->current_picture.qscale_table[mb_pos - 1];
3082 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3083 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3084 if ( dc_pred_dir && n == 1)
3086 if (!dc_pred_dir && n == 2)
3088 if (n == 3) q2 = q1;
3091 int last = 0, skip, value;
3095 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3099 if (v->fcm == PROGRESSIVE)
3100 block[v->zz_8x8[0][i++]] = value;
3102 if (use_pred && (v->fcm == ILACE_FRAME)) {
3103 if (!dc_pred_dir) // top
3104 block[v->zz_8x8[2][i++]] = value;
3106 block[v->zz_8x8[3][i++]] = value;
3108 block[v->zzi_8x8[i++]] = value;
3113 /* apply AC prediction if needed */
3115 /* scale predictors if needed*/
3116 if (q2 && q1 != q2) {
3117 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3118 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3121 return AVERROR_INVALIDDATA;
3122 if (dc_pred_dir) { // left
3123 for (k = 1; k < 8; k++)
3124 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3126 for (k = 1; k < 8; k++)
3127 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3130 if (dc_pred_dir) { // left
3131 for (k = 1; k < 8; k++)
3132 block[k << v->left_blk_sh] += ac_val[k];
3134 for (k = 1; k < 8; k++)
3135 block[k << v->top_blk_sh] += ac_val[k + 8];
3139 /* save AC coeffs for further prediction */
3140 for (k = 1; k < 8; k++) {
3141 ac_val2[k ] = block[k << v->left_blk_sh];
3142 ac_val2[k + 8] = block[k << v->top_blk_sh];
3145 /* scale AC coeffs */
3146 for (k = 1; k < 64; k++)
3150 block[k] += (block[k] < 0) ? -mquant : mquant;
3153 if (use_pred) i = 63;
3154 } else { // no AC coeffs
3157 memset(ac_val2, 0, 16 * 2);
3158 if (dc_pred_dir) { // left
3160 memcpy(ac_val2, ac_val, 8 * 2);
3161 if (q2 && q1 != q2) {
3162 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3163 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3165 return AVERROR_INVALIDDATA;
3166 for (k = 1; k < 8; k++)
3167 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3172 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3173 if (q2 && q1 != q2) {
3174 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3175 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3177 return AVERROR_INVALIDDATA;
3178 for (k = 1; k < 8; k++)
3179 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3184 /* apply AC prediction if needed */
3186 if (dc_pred_dir) { // left
3187 for (k = 1; k < 8; k++) {
3188 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3189 if (!v->pquantizer && block[k << v->left_blk_sh])
3190 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3193 for (k = 1; k < 8; k++) {
3194 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3195 if (!v->pquantizer && block[k << v->top_blk_sh])
3196 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3202 s->block_last_index[n] = i;
3209 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
3210 int mquant, int ttmb, int first_block,
3211 uint8_t *dst, int linesize, int skip_block,
3214 MpegEncContext *s = &v->s;
3215 GetBitContext *gb = &s->gb;
3218 int scale, off, idx, last, skip, value;
3219 int ttblk = ttmb & 7;
3222 s->dsp.clear_block(block);
3225 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)];
3227 if (ttblk == TT_4X4) {
3228 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3230 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3231 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3232 || (!v->res_rtm_flag && !first_block))) {
3233 subblkpat = decode012(gb);
3235 subblkpat ^= 3; // swap decoded pattern bits
3236 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3238 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3241 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3243 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3244 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3245 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3248 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3249 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3258 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3263 idx = v->zz_8x8[0][i++];
3265 idx = v->zzi_8x8[i++];
3266 block[idx] = value * scale;
3268 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3272 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3274 v->vc1dsp.vc1_inv_trans_8x8(block);
3275 s->dsp.add_pixels_clamped(block, dst, linesize);
3280 pat = ~subblkpat & 0xF;
3281 for (j = 0; j < 4; j++) {
3282 last = subblkpat & (1 << (3 - j));
3284 off = (j & 1) * 4 + (j & 2) * 16;
3286 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3291 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3293 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3294 block[idx + off] = value * scale;
3296 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3298 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3300 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3302 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3307 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3308 for (j = 0; j < 2; j++) {
3309 last = subblkpat & (1 << (1 - j));
3313 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3318 idx = v->zz_8x4[i++] + off;
3320 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3321 block[idx] = value * scale;
3323 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3325 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3327 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3329 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3334 pat = ~(subblkpat * 5) & 0xF;
3335 for (j = 0; j < 2; j++) {
3336 last = subblkpat & (1 << (1 - j));
3340 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3345 idx = v->zz_4x8[i++] + off;
3347 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3348 block[idx] = value * scale;
3350 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3352 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3354 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3356 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3362 *ttmb_out |= ttblk << (n * 4);
3366 /** @} */ // Macroblock group
3368 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3369 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3371 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3373 MpegEncContext *s = &v->s;
3374 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3375 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3376 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3377 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3378 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3381 if (block_num > 3) {
3382 dst = s->dest[block_num - 3];
3384 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3386 if (s->mb_y != s->end_mb_y || block_num < 2) {
3390 if (block_num > 3) {
3391 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3392 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3393 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3394 mv_stride = s->mb_stride;
3396 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3397 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3398 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3399 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3400 mv_stride = s->b8_stride;
3401 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3404 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3405 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3406 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3408 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3410 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3413 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3415 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3420 dst -= 4 * linesize;
3421 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3422 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3423 idx = (block_cbp | (block_cbp >> 2)) & 3;
3425 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3428 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3430 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3435 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3437 MpegEncContext *s = &v->s;
3438 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3439 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3440 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3441 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3442 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3445 if (block_num > 3) {
3446 dst = s->dest[block_num - 3] - 8 * linesize;
3448 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3451 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3454 if (block_num > 3) {
3455 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3456 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3457 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3459 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3460 : (mb_cbp >> ((block_num + 1) * 4));
3461 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3462 : (mb_is_intra >> ((block_num + 1) * 4));
3463 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3465 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3466 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3468 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3470 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3473 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3475 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3481 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3482 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3483 idx = (block_cbp | (block_cbp >> 1)) & 5;
3485 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3488 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3490 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3495 static void vc1_apply_p_loop_filter(VC1Context *v)
3497 MpegEncContext *s = &v->s;
3500 for (i = 0; i < 6; i++) {
3501 vc1_apply_p_v_loop_filter(v, i);
3504 /* V always precedes H, therefore we run H one MB before V;
3505 * at the end of a row, we catch up to complete the row */
3507 for (i = 0; i < 6; i++) {
3508 vc1_apply_p_h_loop_filter(v, i);
3510 if (s->mb_x == s->mb_width - 1) {
3512 ff_update_block_index(s);
3513 for (i = 0; i < 6; i++) {
3514 vc1_apply_p_h_loop_filter(v, i);
3520 /** Decode one P-frame MB
3522 static int vc1_decode_p_mb(VC1Context *v)
3524 MpegEncContext *s = &v->s;
3525 GetBitContext *gb = &s->gb;
3527 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3528 int cbp; /* cbp decoding stuff */
3529 int mqdiff, mquant; /* MB quantization */
3530 int ttmb = v->ttfrm; /* MB Transform type */
3532 int mb_has_coeffs = 1; /* last_flag */
3533 int dmv_x, dmv_y; /* Differential MV components */
3534 int index, index1; /* LUT indexes */
3535 int val, sign; /* temp values */
3536 int first_block = 1;
3538 int skipped, fourmv;
3539 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3541 mquant = v->pq; /* lossy initialization */
3543 if (v->mv_type_is_raw)
3544 fourmv = get_bits1(gb);
3546 fourmv = v->mv_type_mb_plane[mb_pos];
3548 skipped = get_bits1(gb);
3550 skipped = v->s.mbskip_table[mb_pos];
3552 if (!fourmv) { /* 1MV mode */
3554 GET_MVDATA(dmv_x, dmv_y);
3557 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3558 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3560 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3561 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3563 /* FIXME Set DC val for inter block ? */
3564 if (s->mb_intra && !mb_has_coeffs) {
3566 s->ac_pred = get_bits1(gb);
3568 } else if (mb_has_coeffs) {
3570 s->ac_pred = get_bits1(gb);
3571 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3577 s->current_picture.qscale_table[mb_pos] = mquant;
3579 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3580 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3581 VC1_TTMB_VLC_BITS, 2);
3582 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3584 for (i = 0; i < 6; i++) {
3585 s->dc_val[0][s->block_index[i]] = 0;
3587 val = ((cbp >> (5 - i)) & 1);
3588 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3589 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3591 /* check if prediction blocks A and C are available */
3592 v->a_avail = v->c_avail = 0;
3593 if (i == 2 || i == 3 || !s->first_slice_line)
3594 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3595 if (i == 1 || i == 3 || s->mb_x)
3596 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3598 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3599 (i & 4) ? v->codingset2 : v->codingset);
3600 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3602 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3604 for (j = 0; j < 64; j++)
3605 s->block[i][j] <<= 1;
3606 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3607 if (v->pq >= 9 && v->overlap) {
3609 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3611 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3613 block_cbp |= 0xF << (i << 2);
3614 block_intra |= 1 << i;
3616 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3617 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3618 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3619 block_cbp |= pat << (i << 2);
3620 if (!v->ttmbf && ttmb < 8)
3627 for (i = 0; i < 6; i++) {
3628 v->mb_type[0][s->block_index[i]] = 0;
3629 s->dc_val[0][s->block_index[i]] = 0;
3631 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3632 s->current_picture.qscale_table[mb_pos] = 0;
3633 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3636 } else { // 4MV mode
3637 if (!skipped /* unskipped MB */) {
3638 int intra_count = 0, coded_inter = 0;
3639 int is_intra[6], is_coded[6];
3641 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3642 for (i = 0; i < 6; i++) {
3643 val = ((cbp >> (5 - i)) & 1);
3644 s->dc_val[0][s->block_index[i]] = 0;
3651 GET_MVDATA(dmv_x, dmv_y);
3653 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3655 vc1_mc_4mv_luma(v, i, 0, 0);
3656 intra_count += s->mb_intra;
3657 is_intra[i] = s->mb_intra;
3658 is_coded[i] = mb_has_coeffs;
3661 is_intra[i] = (intra_count >= 3);
3665 vc1_mc_4mv_chroma(v, 0);
3666 v->mb_type[0][s->block_index[i]] = is_intra[i];
3668 coded_inter = !is_intra[i] & is_coded[i];
3670 // if there are no coded blocks then don't do anything more
3672 if (!intra_count && !coded_inter)
3675 s->current_picture.qscale_table[mb_pos] = mquant;
3676 /* test if block is intra and has pred */
3679 for (i = 0; i < 6; i++)
3681 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3682 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3688 s->ac_pred = get_bits1(gb);
3692 if (!v->ttmbf && coded_inter)
3693 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3694 for (i = 0; i < 6; i++) {
3696 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3697 s->mb_intra = is_intra[i];
3699 /* check if prediction blocks A and C are available */
3700 v->a_avail = v->c_avail = 0;
3701 if (i == 2 || i == 3 || !s->first_slice_line)
3702 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3703 if (i == 1 || i == 3 || s->mb_x)
3704 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3706 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3707 (i & 4) ? v->codingset2 : v->codingset);
3708 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3710 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3712 for (j = 0; j < 64; j++)
3713 s->block[i][j] <<= 1;
3714 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3715 (i & 4) ? s->uvlinesize : s->linesize);
3716 if (v->pq >= 9 && v->overlap) {
3718 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3720 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3722 block_cbp |= 0xF << (i << 2);
3723 block_intra |= 1 << i;
3724 } else if (is_coded[i]) {
3725 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3726 first_block, s->dest[dst_idx] + off,
3727 (i & 4) ? s->uvlinesize : s->linesize,
3728 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3730 block_cbp |= pat << (i << 2);
3731 if (!v->ttmbf && ttmb < 8)
3736 } else { // skipped MB
3738 s->current_picture.qscale_table[mb_pos] = 0;
3739 for (i = 0; i < 6; i++) {
3740 v->mb_type[0][s->block_index[i]] = 0;
3741 s->dc_val[0][s->block_index[i]] = 0;
3743 for (i = 0; i < 4; i++) {
3744 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3745 vc1_mc_4mv_luma(v, i, 0, 0);
3747 vc1_mc_4mv_chroma(v, 0);
3748 s->current_picture.qscale_table[mb_pos] = 0;
3752 v->cbp[s->mb_x] = block_cbp;
3753 v->ttblk[s->mb_x] = block_tt;
3754 v->is_intra[s->mb_x] = block_intra;
3759 /* Decode one macroblock in an interlaced frame p picture */
3761 static int vc1_decode_p_mb_intfr(VC1Context *v)
3763 MpegEncContext *s = &v->s;
3764 GetBitContext *gb = &s->gb;
3766 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3767 int cbp = 0; /* cbp decoding stuff */
3768 int mqdiff, mquant; /* MB quantization */
3769 int ttmb = v->ttfrm; /* MB Transform type */
3771 int mb_has_coeffs = 1; /* last_flag */
3772 int dmv_x, dmv_y; /* Differential MV components */
3773 int val; /* temp value */
3774 int first_block = 1;
3776 int skipped, fourmv = 0, twomv = 0;
3777 int block_cbp = 0, pat, block_tt = 0;
3778 int idx_mbmode = 0, mvbp;
3779 int stride_y, fieldtx;
3781 mquant = v->pq; /* Lossy initialization */
3784 skipped = get_bits1(gb);
3786 skipped = v->s.mbskip_table[mb_pos];
3788 if (v->fourmvswitch)
3789 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3791 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3792 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3793 /* store the motion vector type in a flag (useful later) */
3794 case MV_PMODE_INTFR_4MV:
3796 v->blk_mv_type[s->block_index[0]] = 0;
3797 v->blk_mv_type[s->block_index[1]] = 0;
3798 v->blk_mv_type[s->block_index[2]] = 0;
3799 v->blk_mv_type[s->block_index[3]] = 0;
3801 case MV_PMODE_INTFR_4MV_FIELD:
3803 v->blk_mv_type[s->block_index[0]] = 1;
3804 v->blk_mv_type[s->block_index[1]] = 1;
3805 v->blk_mv_type[s->block_index[2]] = 1;
3806 v->blk_mv_type[s->block_index[3]] = 1;
3808 case MV_PMODE_INTFR_2MV_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_1MV:
3816 v->blk_mv_type[s->block_index[0]] = 0;
3817 v->blk_mv_type[s->block_index[1]] = 0;
3818 v->blk_mv_type[s->block_index[2]] = 0;
3819 v->blk_mv_type[s->block_index[3]] = 0;
3822 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3823 for (i = 0; i < 4; i++) {
3824 s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
3825 s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
3827 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3828 s->mb_intra = v->is_intra[s->mb_x] = 1;
3829 for (i = 0; i < 6; i++)
3830 v->mb_type[0][s->block_index[i]] = 1;
3831 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3832 mb_has_coeffs = get_bits1(gb);
3834 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3835 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3837 s->current_picture.qscale_table[mb_pos] = mquant;
3838 /* Set DC scale - y and c use the same (not sure if necessary here) */
3839 s->y_dc_scale = s->y_dc_scale_table[mquant];
3840 s->c_dc_scale = s->c_dc_scale_table[mquant];
3842 for (i = 0; i < 6; i++) {
3843 s->dc_val[0][s->block_index[i]] = 0;
3845 val = ((cbp >> (5 - i)) & 1);
3846 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3847 v->a_avail = v->c_avail = 0;
3848 if (i == 2 || i == 3 || !s->first_slice_line)
3849 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3850 if (i == 1 || i == 3 || s->mb_x)
3851 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3853 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3854 (i & 4) ? v->codingset2 : v->codingset);
3855 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3856 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3858 stride_y = s->linesize << fieldtx;
3859 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3861 stride_y = s->uvlinesize;
3864 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3868 } else { // inter MB
3869 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3871 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3872 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3873 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3875 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3876 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3877 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3880 s->mb_intra = v->is_intra[s->mb_x] = 0;
3881 for (i = 0; i < 6; i++)
3882 v->mb_type[0][s->block_index[i]] = 0;
3883 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3884 /* for all motion vector read MVDATA and motion compensate each block */
3888 for (i = 0; i < 6; i++) {
3891 val = ((mvbp >> (3 - i)) & 1);
3893 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3895 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0);
3896 vc1_mc_4mv_luma(v, i, 0, 0);
3897 } else if (i == 4) {
3898 vc1_mc_4mv_chroma4(v, 0, 0, 0);
3905 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3907 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3908 vc1_mc_4mv_luma(v, 0, 0, 0);
3909 vc1_mc_4mv_luma(v, 1, 0, 0);
3912 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3914 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3915 vc1_mc_4mv_luma(v, 2, 0, 0);
3916 vc1_mc_4mv_luma(v, 3, 0, 0);
3917 vc1_mc_4mv_chroma4(v, 0, 0, 0);
3919 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3922 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3924 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3928 GET_MQUANT(); // p. 227
3929 s->current_picture.qscale_table[mb_pos] = mquant;
3930 if (!v->ttmbf && cbp)
3931 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3932 for (i = 0; i < 6; i++) {
3933 s->dc_val[0][s->block_index[i]] = 0;
3935 val = ((cbp >> (5 - i)) & 1);
3937 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3939 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3941 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3942 first_block, s->dest[dst_idx] + off,
3943 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3944 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3945 block_cbp |= pat << (i << 2);
3946 if (!v->ttmbf && ttmb < 8)
3953 s->mb_intra = v->is_intra[s->mb_x] = 0;
3954 for (i = 0; i < 6; i++) {
3955 v->mb_type[0][s->block_index[i]] = 0;
3956 s->dc_val[0][s->block_index[i]] = 0;
3958 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3959 s->current_picture.qscale_table[mb_pos] = 0;
3960 v->blk_mv_type[s->block_index[0]] = 0;
3961 v->blk_mv_type[s->block_index[1]] = 0;
3962 v->blk_mv_type[s->block_index[2]] = 0;
3963 v->blk_mv_type[s->block_index[3]] = 0;
3964 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3967 if (s->mb_x == s->mb_width - 1)
3968 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3972 static int vc1_decode_p_mb_intfi(VC1Context *v)
3974 MpegEncContext *s = &v->s;
3975 GetBitContext *gb = &s->gb;
3977 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3978 int cbp = 0; /* cbp decoding stuff */
3979 int mqdiff, mquant; /* MB quantization */
3980 int ttmb = v->ttfrm; /* MB Transform type */
3982 int mb_has_coeffs = 1; /* last_flag */
3983 int dmv_x, dmv_y; /* Differential MV components */
3984 int val; /* temp values */
3985 int first_block = 1;
3988 int block_cbp = 0, pat, block_tt = 0;
3991 mquant = v->pq; /* Lossy initialization */
3993 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3994 if (idx_mbmode <= 1) { // intra MB
3995 s->mb_intra = v->is_intra[s->mb_x] = 1;
3996 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3997 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3998 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4000 s->current_picture.qscale_table[mb_pos] = mquant;
4001 /* Set DC scale - y and c use the same (not sure if necessary here) */
4002 s->y_dc_scale = s->y_dc_scale_table[mquant];
4003 s->c_dc_scale = s->c_dc_scale_table[mquant];
4004 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4005 mb_has_coeffs = idx_mbmode & 1;
4007 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4009 for (i = 0; i < 6; i++) {
4010 s->dc_val[0][s->block_index[i]] = 0;
4011 v->mb_type[0][s->block_index[i]] = 1;
4013 val = ((cbp >> (5 - i)) & 1);
4014 v->a_avail = v->c_avail = 0;
4015 if (i == 2 || i == 3 || !s->first_slice_line)
4016 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4017 if (i == 1 || i == 3 || s->mb_x)
4018 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4020 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4021 (i & 4) ? v->codingset2 : v->codingset);
4022 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4024 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4025 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4026 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4027 // TODO: loop filter
4030 s->mb_intra = v->is_intra[s->mb_x] = 0;
4031 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4032 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4033 if (idx_mbmode <= 5) { // 1-MV
4034 dmv_x = dmv_y = pred_flag = 0;
4035 if (idx_mbmode & 1) {
4036 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4038 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4040 mb_has_coeffs = !(idx_mbmode & 2);
4042 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4043 for (i = 0; i < 6; i++) {
4045 dmv_x = dmv_y = pred_flag = 0;
4046 val = ((v->fourmvbp >> (3 - i)) & 1);
4048 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4050 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4051 vc1_mc_4mv_luma(v, i, 0, 0);
4053 vc1_mc_4mv_chroma(v, 0);
4055 mb_has_coeffs = idx_mbmode & 1;
4058 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4062 s->current_picture.qscale_table[mb_pos] = mquant;
4063 if (!v->ttmbf && cbp) {
4064 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4067 for (i = 0; i < 6; i++) {
4068 s->dc_val[0][s->block_index[i]] = 0;
4070 val = ((cbp >> (5 - i)) & 1);
4071 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4073 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4074 first_block, s->dest[dst_idx] + off,
4075 (i & 4) ? s->uvlinesize : s->linesize,
4076 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
4078 block_cbp |= pat << (i << 2);
4079 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4084 if (s->mb_x == s->mb_width - 1)
4085 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4089 /** Decode one B-frame MB (in Main profile)
4091 static void vc1_decode_b_mb(VC1Context *v)
4093 MpegEncContext *s = &v->s;
4094 GetBitContext *gb = &s->gb;
4096 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4097 int cbp = 0; /* cbp decoding stuff */
4098 int mqdiff, mquant; /* MB quantization */
4099 int ttmb = v->ttfrm; /* MB Transform type */
4100 int mb_has_coeffs = 0; /* last_flag */
4101 int index, index1; /* LUT indexes */
4102 int val, sign; /* temp values */
4103 int first_block = 1;
4105 int skipped, direct;
4106 int dmv_x[2], dmv_y[2];
4107 int bmvtype = BMV_TYPE_BACKWARD;
4109 mquant = v->pq; /* lossy initialization */
4113 direct = get_bits1(gb);
4115 direct = v->direct_mb_plane[mb_pos];
4117 skipped = get_bits1(gb);
4119 skipped = v->s.mbskip_table[mb_pos];
4121 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4122 for (i = 0; i < 6; i++) {
4123 v->mb_type[0][s->block_index[i]] = 0;
4124 s->dc_val[0][s->block_index[i]] = 0;
4126 s->current_picture.qscale_table[mb_pos] = 0;
4130 GET_MVDATA(dmv_x[0], dmv_y[0]);
4131 dmv_x[1] = dmv_x[0];
4132 dmv_y[1] = dmv_y[0];
4134 if (skipped || !s->mb_intra) {
4135 bmvtype = decode012(gb);
4138 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4141 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4144 bmvtype = BMV_TYPE_INTERPOLATED;
4145 dmv_x[0] = dmv_y[0] = 0;
4149 for (i = 0; i < 6; i++)
4150 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4154 bmvtype = BMV_TYPE_INTERPOLATED;
4155 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4156 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4160 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4163 s->current_picture.qscale_table[mb_pos] = mquant;
4165 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4166 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4167 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4168 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4170 if (!mb_has_coeffs && !s->mb_intra) {
4171 /* no coded blocks - effectively skipped */
4172 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4173 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4176 if (s->mb_intra && !mb_has_coeffs) {
4178 s->current_picture.qscale_table[mb_pos] = mquant;
4179 s->ac_pred = get_bits1(gb);
4181 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4183 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4184 GET_MVDATA(dmv_x[0], dmv_y[0]);
4185 if (!mb_has_coeffs) {
4186 /* interpolated skipped block */
4187 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4188 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4192 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4194 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4197 s->ac_pred = get_bits1(gb);
4198 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4200 s->current_picture.qscale_table[mb_pos] = mquant;
4201 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4202 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4206 for (i = 0; i < 6; i++) {
4207 s->dc_val[0][s->block_index[i]] = 0;
4209 val = ((cbp >> (5 - i)) & 1);
4210 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4211 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4213 /* check if prediction blocks A and C are available */
4214 v->a_avail = v->c_avail = 0;
4215 if (i == 2 || i == 3 || !s->first_slice_line)
4216 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4217 if (i == 1 || i == 3 || s->mb_x)
4218 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4220 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4221 (i & 4) ? v->codingset2 : v->codingset);
4222 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4224 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4226 for (j = 0; j < 64; j++)
4227 s->block[i][j] <<= 1;
4228 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4230 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4231 first_block, s->dest[dst_idx] + off,
4232 (i & 4) ? s->uvlinesize : s->linesize,
4233 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4234 if (!v->ttmbf && ttmb < 8)
4241 /** Decode one B-frame MB (in interlaced field B picture)
4243 static void vc1_decode_b_mb_intfi(VC1Context *v)
4245 MpegEncContext *s = &v->s;
4246 GetBitContext *gb = &s->gb;
4248 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4249 int cbp = 0; /* cbp decoding stuff */
4250 int mqdiff, mquant; /* MB quantization */
4251 int ttmb = v->ttfrm; /* MB Transform type */
4252 int mb_has_coeffs = 0; /* last_flag */
4253 int val; /* temp value */
4254 int first_block = 1;
4257 int dmv_x[2], dmv_y[2], pred_flag[2];
4258 int bmvtype = BMV_TYPE_BACKWARD;
4261 mquant = v->pq; /* Lossy initialization */
4264 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4265 if (idx_mbmode <= 1) { // intra MB
4266 s->mb_intra = v->is_intra[s->mb_x] = 1;
4267 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4268 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4269 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4271 s->current_picture.qscale_table[mb_pos] = mquant;
4272 /* Set DC scale - y and c use the same (not sure if necessary here) */
4273 s->y_dc_scale = s->y_dc_scale_table[mquant];
4274 s->c_dc_scale = s->c_dc_scale_table[mquant];
4275 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4276 mb_has_coeffs = idx_mbmode & 1;
4278 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4280 for (i = 0; i < 6; i++) {
4281 s->dc_val[0][s->block_index[i]] = 0;
4283 val = ((cbp >> (5 - i)) & 1);
4284 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4285 v->a_avail = v->c_avail = 0;
4286 if (i == 2 || i == 3 || !s->first_slice_line)
4287 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4288 if (i == 1 || i == 3 || s->mb_x)
4289 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4291 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4292 (i & 4) ? v->codingset2 : v->codingset);
4293 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4295 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4297 for (j = 0; j < 64; j++)
4298 s->block[i][j] <<= 1;
4299 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4300 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4301 // TODO: yet to perform loop filter
4304 s->mb_intra = v->is_intra[s->mb_x] = 0;
4305 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4306 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4308 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4310 fwd = v->forward_mb_plane[mb_pos];
4311 if (idx_mbmode <= 5) { // 1-MV
4313 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4314 pred_flag[0] = pred_flag[1] = 0;
4316 bmvtype = BMV_TYPE_FORWARD;
4318 bmvtype = decode012(gb);
4321 bmvtype = BMV_TYPE_BACKWARD;
4324 bmvtype = BMV_TYPE_DIRECT;
4327 bmvtype = BMV_TYPE_INTERPOLATED;
4328 interpmvp = get_bits1(gb);
4331 v->bmvtype = bmvtype;
4332 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4333 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4336 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4338 if (bmvtype == BMV_TYPE_DIRECT) {
4339 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4340 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4342 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4343 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4344 mb_has_coeffs = !(idx_mbmode & 2);
4347 bmvtype = BMV_TYPE_FORWARD;
4348 v->bmvtype = bmvtype;
4349 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4350 for (i = 0; i < 6; i++) {
4352 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4353 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4354 val = ((v->fourmvbp >> (3 - i)) & 1);
4356 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4357 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4358 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4360 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4361 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD, 0);
4363 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4365 mb_has_coeffs = idx_mbmode & 1;
4368 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4372 s->current_picture.qscale_table[mb_pos] = mquant;
4373 if (!v->ttmbf && cbp) {
4374 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4377 for (i = 0; i < 6; i++) {
4378 s->dc_val[0][s->block_index[i]] = 0;
4380 val = ((cbp >> (5 - i)) & 1);
4381 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4383 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4384 first_block, s->dest[dst_idx] + off,
4385 (i & 4) ? s->uvlinesize : s->linesize,
4386 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4387 if (!v->ttmbf && ttmb < 8)
4395 /** Decode one B-frame MB (in interlaced frame B picture)
4397 static int vc1_decode_b_mb_intfr(VC1Context *v)
4399 MpegEncContext *s = &v->s;
4400 GetBitContext *gb = &s->gb;
4402 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4403 int cbp = 0; /* cbp decoding stuff */
4404 int mqdiff, mquant; /* MB quantization */
4405 int ttmb = v->ttfrm; /* MB Transform type */
4406 int mvsw = 0; /* motion vector switch */
4407 int mb_has_coeffs = 1; /* last_flag */
4408 int dmv_x, dmv_y; /* Differential MV components */
4409 int val; /* temp value */
4410 int first_block = 1;
4412 int skipped, direct, twomv = 0;
4413 int block_cbp = 0, pat, block_tt = 0;
4414 int idx_mbmode = 0, mvbp;
4415 int stride_y, fieldtx;
4416 int bmvtype = BMV_TYPE_BACKWARD;
4419 mquant = v->pq; /* Lossy initialization */
4422 skipped = get_bits1(gb);
4424 skipped = v->s.mbskip_table[mb_pos];
4427 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
4428 if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
4430 v->blk_mv_type[s->block_index[0]] = 1;
4431 v->blk_mv_type[s->block_index[1]] = 1;
4432 v->blk_mv_type[s->block_index[2]] = 1;
4433 v->blk_mv_type[s->block_index[3]] = 1;
4435 v->blk_mv_type[s->block_index[0]] = 0;
4436 v->blk_mv_type[s->block_index[1]] = 0;
4437 v->blk_mv_type[s->block_index[2]] = 0;
4438 v->blk_mv_type[s->block_index[3]] = 0;
4443 direct = get_bits1(gb);
4445 direct = v->direct_mb_plane[mb_pos];
4448 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);
4449 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);
4450 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);
4451 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);
4454 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);
4455 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);
4456 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);
4457 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);
4459 for (i = 1; i < 4; i += 2) {
4460 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
4461 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
4462 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
4463 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
4466 for (i = 1; i < 4; i++) {
4467 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
4468 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
4469 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
4470 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
4475 if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
4476 for (i = 0; i < 4; i++) {
4477 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;
4478 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;
4479 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
4480 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
4482 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4483 s->mb_intra = v->is_intra[s->mb_x] = 1;
4484 for (i = 0; i < 6; i++)
4485 v->mb_type[0][s->block_index[i]] = 1;
4486 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
4487 mb_has_coeffs = get_bits1(gb);
4489 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4490 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4492 s->current_picture.qscale_table[mb_pos] = mquant;
4493 /* Set DC scale - y and c use the same (not sure if necessary here) */
4494 s->y_dc_scale = s->y_dc_scale_table[mquant];
4495 s->c_dc_scale = s->c_dc_scale_table[mquant];
4497 for (i = 0; i < 6; i++) {
4498 s->dc_val[0][s->block_index[i]] = 0;
4500 val = ((cbp >> (5 - i)) & 1);
4501 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4502 v->a_avail = v->c_avail = 0;
4503 if (i == 2 || i == 3 || !s->first_slice_line)
4504 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4505 if (i == 1 || i == 3 || s->mb_x)
4506 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4508 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4509 (i & 4) ? v->codingset2 : v->codingset);
4510 if (i > 3 && (s->flags & CODEC_FLAG_GRAY))
4512 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4514 stride_y = s->linesize << fieldtx;
4515 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
4517 stride_y = s->uvlinesize;
4520 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
4523 s->mb_intra = v->is_intra[s->mb_x] = 0;
4525 if (skipped || !s->mb_intra) {
4526 bmvtype = decode012(gb);
4529 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4532 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4535 bmvtype = BMV_TYPE_INTERPOLATED;
4539 if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
4540 mvsw = get_bits1(gb);
4543 if (!skipped) { // inter MB
4544 mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
4546 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4548 if (bmvtype == BMV_TYPE_INTERPOLATED & twomv) {
4549 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4550 } else if (bmvtype == BMV_TYPE_INTERPOLATED | twomv) {
4551 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
4555 for (i = 0; i < 6; i++)
4556 v->mb_type[0][s->block_index[i]] = 0;
4557 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1];
4558 /* for all motion vector read MVDATA and motion compensate each block */
4562 for (i = 0; i < 4; i++) {
4563 vc1_mc_4mv_luma(v, i, 0, 0);
4564 vc1_mc_4mv_luma(v, i, 1, 1);
4566 vc1_mc_4mv_chroma4(v, 0, 0, 0);
4567 vc1_mc_4mv_chroma4(v, 1, 1, 1);
4572 } else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) {
4574 for (i = 0; i < 4; i++) {
4577 val = ((mvbp >> (3 - i)) & 1);
4579 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4581 vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4582 vc1_mc_4mv_luma(v, j, dir, dir);
4583 vc1_mc_4mv_luma(v, j+1, dir, dir);
4586 vc1_mc_4mv_chroma4(v, 0, 0, 0);
4587 vc1_mc_4mv_chroma4(v, 1, 1, 1);
4588 } else if (bmvtype == BMV_TYPE_INTERPOLATED) {
4592 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4594 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4599 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4601 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4604 dir = bmvtype == BMV_TYPE_BACKWARD;
4611 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4612 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4616 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4617 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir2);
4620 for (i = 0; i < 2; i++) {
4621 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];
4622 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];
4623 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];
4624 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];
4627 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4628 vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4631 vc1_mc_4mv_luma(v, 0, dir, 0);
4632 vc1_mc_4mv_luma(v, 1, dir, 0);
4633 vc1_mc_4mv_luma(v, 2, dir2, 0);
4634 vc1_mc_4mv_luma(v, 3, dir2, 0);
4635 vc1_mc_4mv_chroma4(v, dir, dir2, 0);
4637 dir = bmvtype == BMV_TYPE_BACKWARD;
4639 mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2];
4642 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4644 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4645 v->blk_mv_type[s->block_index[0]] = 1;
4646 v->blk_mv_type[s->block_index[1]] = 1;
4647 v->blk_mv_type[s->block_index[2]] = 1;
4648 v->blk_mv_type[s->block_index[3]] = 1;
4649 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4650 for (i = 0; i < 2; i++) {
4651 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];
4652 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];
4658 GET_MQUANT(); // p. 227
4659 s->current_picture.qscale_table[mb_pos] = mquant;
4660 if (!v->ttmbf && cbp)
4661 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4662 for (i = 0; i < 6; i++) {
4663 s->dc_val[0][s->block_index[i]] = 0;
4665 val = ((cbp >> (5 - i)) & 1);
4667 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4669 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
4671 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4672 first_block, s->dest[dst_idx] + off,
4673 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
4674 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
4675 block_cbp |= pat << (i << 2);
4676 if (!v->ttmbf && ttmb < 8)
4684 for (i = 0; i < 6; i++) {
4685 v->mb_type[0][s->block_index[i]] = 0;
4686 s->dc_val[0][s->block_index[i]] = 0;
4688 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
4689 s->current_picture.qscale_table[mb_pos] = 0;
4690 v->blk_mv_type[s->block_index[0]] = 0;
4691 v->blk_mv_type[s->block_index[1]] = 0;
4692 v->blk_mv_type[s->block_index[2]] = 0;
4693 v->blk_mv_type[s->block_index[3]] = 0;
4696 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4697 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4698 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4700 dir = bmvtype == BMV_TYPE_BACKWARD;
4701 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4706 for (i = 0; i < 2; i++) {
4707 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];
4708 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];
4709 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];
4710 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];
4713 v->blk_mv_type[s->block_index[0]] = 1;
4714 v->blk_mv_type[s->block_index[1]] = 1;
4715 v->blk_mv_type[s->block_index[2]] = 1;
4716 v->blk_mv_type[s->block_index[3]] = 1;
4717 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4718 for (i = 0; i < 2; i++) {
4719 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];
4720 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];
4727 if (direct || bmvtype == BMV_TYPE_INTERPOLATED) {
4732 if (s->mb_x == s->mb_width - 1)
4733 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4734 v->cbp[s->mb_x] = block_cbp;
4735 v->ttblk[s->mb_x] = block_tt;
4739 /** Decode blocks of I-frame
4741 static void vc1_decode_i_blocks(VC1Context *v)
4744 MpegEncContext *s = &v->s;
4749 /* select codingmode used for VLC tables selection */
4750 switch (v->y_ac_table_index) {
4752 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4755 v->codingset = CS_HIGH_MOT_INTRA;
4758 v->codingset = CS_MID_RATE_INTRA;
4762 switch (v->c_ac_table_index) {
4764 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4767 v->codingset2 = CS_HIGH_MOT_INTER;
4770 v->codingset2 = CS_MID_RATE_INTER;
4774 /* Set DC scale - y and c use the same */
4775 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4776 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4779 s->mb_x = s->mb_y = 0;
4781 s->first_slice_line = 1;
4782 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4784 init_block_index(v);
4785 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4787 ff_update_block_index(s);
4788 dst[0] = s->dest[0];
4789 dst[1] = dst[0] + 8;
4790 dst[2] = s->dest[0] + s->linesize * 8;
4791 dst[3] = dst[2] + 8;
4792 dst[4] = s->dest[1];
4793 dst[5] = s->dest[2];
4794 s->dsp.clear_blocks(s->block[0]);
4795 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4796 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4797 s->current_picture.qscale_table[mb_pos] = v->pq;
4798 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4799 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4801 // do actual MB decoding and displaying
4802 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4803 v->s.ac_pred = get_bits1(&v->s.gb);
4805 for (k = 0; k < 6; k++) {
4806 val = ((cbp >> (5 - k)) & 1);
4809 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4813 cbp |= val << (5 - k);
4815 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4817 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4819 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4820 if (v->pq >= 9 && v->overlap) {
4822 for (j = 0; j < 64; j++)
4823 s->block[k][j] <<= 1;
4824 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4827 for (j = 0; j < 64; j++)
4828 s->block[k][j] = (s->block[k][j] - 64) << 1;
4829 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4833 if (v->pq >= 9 && v->overlap) {
4835 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4836 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4837 if (!(s->flags & CODEC_FLAG_GRAY)) {
4838 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4839 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4842 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4843 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4844 if (!s->first_slice_line) {
4845 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4846 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4847 if (!(s->flags & CODEC_FLAG_GRAY)) {
4848 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4849 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4852 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4853 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4855 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4857 if (get_bits_count(&s->gb) > v->bits) {
4858 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4859 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4860 get_bits_count(&s->gb), v->bits);
4864 if (!v->s.loop_filter)
4865 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4867 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4869 s->first_slice_line = 0;
4871 if (v->s.loop_filter)
4872 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4874 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4875 * profile, these only differ are when decoding MSS2 rectangles. */
4876 ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4879 /** Decode blocks of I-frame for advanced profile
4881 static void vc1_decode_i_blocks_adv(VC1Context *v)
4884 MpegEncContext *s = &v->s;
4890 GetBitContext *gb = &s->gb;
4892 /* select codingmode used for VLC tables selection */
4893 switch (v->y_ac_table_index) {
4895 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4898 v->codingset = CS_HIGH_MOT_INTRA;
4901 v->codingset = CS_MID_RATE_INTRA;
4905 switch (v->c_ac_table_index) {
4907 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4910 v->codingset2 = CS_HIGH_MOT_INTER;
4913 v->codingset2 = CS_MID_RATE_INTER;
4918 s->mb_x = s->mb_y = 0;
4920 s->first_slice_line = 1;
4921 s->mb_y = s->start_mb_y;
4922 if (s->start_mb_y) {
4924 init_block_index(v);
4925 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4926 (1 + s->b8_stride) * sizeof(*s->coded_block));
4928 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4930 init_block_index(v);
4931 for (;s->mb_x < s->mb_width; s->mb_x++) {
4932 int16_t (*block)[64] = v->block[v->cur_blk_idx];
4933 ff_update_block_index(s);
4934 s->dsp.clear_blocks(block[0]);
4935 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4936 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4937 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4938 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4940 // do actual MB decoding and displaying
4941 if (v->fieldtx_is_raw)
4942 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4943 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4944 if ( v->acpred_is_raw)
4945 v->s.ac_pred = get_bits1(&v->s.gb);
4947 v->s.ac_pred = v->acpred_plane[mb_pos];
4949 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4950 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4954 s->current_picture.qscale_table[mb_pos] = mquant;
4955 /* Set DC scale - y and c use the same */
4956 s->y_dc_scale = s->y_dc_scale_table[mquant];
4957 s->c_dc_scale = s->c_dc_scale_table[mquant];
4959 for (k = 0; k < 6; k++) {
4960 val = ((cbp >> (5 - k)) & 1);
4963 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4967 cbp |= val << (5 - k);
4969 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4970 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4972 vc1_decode_i_block_adv(v, block[k], k, val,
4973 (k < 4) ? v->codingset : v->codingset2, mquant);
4975 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4977 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4980 vc1_smooth_overlap_filter_iblk(v);
4981 vc1_put_signed_blocks_clamped(v);
4982 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4984 if (get_bits_count(&s->gb) > v->bits) {
4985 // TODO: may need modification to handle slice coding
4986 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4987 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4988 get_bits_count(&s->gb), v->bits);
4992 if (!v->s.loop_filter)
4993 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4995 ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4996 s->first_slice_line = 0;
4999 /* raw bottom MB row */
5001 init_block_index(v);
5003 for (;s->mb_x < s->mb_width; s->mb_x++) {
5004 ff_update_block_index(s);
5005 vc1_put_signed_blocks_clamped(v);
5006 if (v->s.loop_filter)
5007 vc1_loop_filter_iblk_delayed(v, v->pq);
5009 if (v->s.loop_filter)
5010 ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
5011 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5012 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5015 static void vc1_decode_p_blocks(VC1Context *v)
5017 MpegEncContext *s = &v->s;
5018 int apply_loop_filter;
5020 /* select codingmode used for VLC tables selection */
5021 switch (v->c_ac_table_index) {
5023 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5026 v->codingset = CS_HIGH_MOT_INTRA;
5029 v->codingset = CS_MID_RATE_INTRA;
5033 switch (v->c_ac_table_index) {
5035 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5038 v->codingset2 = CS_HIGH_MOT_INTER;
5041 v->codingset2 = CS_MID_RATE_INTER;
5045 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY) &&
5046 v->fcm == PROGRESSIVE;
5047 s->first_slice_line = 1;
5048 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
5049 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5051 init_block_index(v);
5052 for (; s->mb_x < s->mb_width; s->mb_x++) {
5053 ff_update_block_index(s);
5055 if (v->fcm == ILACE_FIELD)
5056 vc1_decode_p_mb_intfi(v);
5057 else if (v->fcm == ILACE_FRAME)
5058 vc1_decode_p_mb_intfr(v);
5059 else vc1_decode_p_mb(v);
5060 if (s->mb_y != s->start_mb_y && apply_loop_filter)
5061 vc1_apply_p_loop_filter(v);
5062 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5063 // TODO: may need modification to handle slice coding
5064 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5065 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5066 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5070 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
5071 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
5072 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
5073 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
5074 if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5075 s->first_slice_line = 0;
5077 if (apply_loop_filter) {
5079 init_block_index(v);
5080 for (; s->mb_x < s->mb_width; s->mb_x++) {
5081 ff_update_block_index(s);
5082 vc1_apply_p_loop_filter(v);
5085 if (s->end_mb_y >= s->start_mb_y)
5086 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5087 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5088 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5091 static void vc1_decode_b_blocks(VC1Context *v)
5093 MpegEncContext *s = &v->s;
5095 /* select codingmode used for VLC tables selection */
5096 switch (v->c_ac_table_index) {
5098 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5101 v->codingset = CS_HIGH_MOT_INTRA;
5104 v->codingset = CS_MID_RATE_INTRA;
5108 switch (v->c_ac_table_index) {
5110 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5113 v->codingset2 = CS_HIGH_MOT_INTER;
5116 v->codingset2 = CS_MID_RATE_INTER;
5120 s->first_slice_line = 1;
5121 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5123 init_block_index(v);
5124 for (; s->mb_x < s->mb_width; s->mb_x++) {
5125 ff_update_block_index(s);
5127 if (v->fcm == ILACE_FIELD)
5128 vc1_decode_b_mb_intfi(v);
5129 else if (v->fcm == ILACE_FRAME)
5130 vc1_decode_b_mb_intfr(v);
5133 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5134 // TODO: may need modification to handle slice coding
5135 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5136 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5137 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5140 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
5142 if (!v->s.loop_filter)
5143 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5145 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5146 s->first_slice_line = 0;
5148 if (v->s.loop_filter)
5149 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5150 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5151 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5154 static void vc1_decode_skip_blocks(VC1Context *v)
5156 MpegEncContext *s = &v->s;
5158 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
5159 s->first_slice_line = 1;
5160 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5162 init_block_index(v);
5163 ff_update_block_index(s);
5164 if (s->last_picture.f.data[0]) {
5165 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
5166 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5167 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5169 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5170 s->first_slice_line = 0;
5172 s->pict_type = AV_PICTURE_TYPE_P;
5175 void ff_vc1_decode_blocks(VC1Context *v)
5178 v->s.esc3_level_length = 0;
5180 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
5183 v->left_blk_idx = -1;
5184 v->topleft_blk_idx = 1;
5186 switch (v->s.pict_type) {
5187 case AV_PICTURE_TYPE_I:
5188 if (v->profile == PROFILE_ADVANCED)
5189 vc1_decode_i_blocks_adv(v);
5191 vc1_decode_i_blocks(v);
5193 case AV_PICTURE_TYPE_P:
5194 if (v->p_frame_skipped)
5195 vc1_decode_skip_blocks(v);
5197 vc1_decode_p_blocks(v);
5199 case AV_PICTURE_TYPE_B:
5201 if (v->profile == PROFILE_ADVANCED)
5202 vc1_decode_i_blocks_adv(v);
5204 vc1_decode_i_blocks(v);
5206 vc1_decode_b_blocks(v);
5212 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5216 * Transform coefficients for both sprites in 16.16 fixed point format,
5217 * in the order they appear in the bitstream:
5219 * rotation 1 (unused)
5221 * rotation 2 (unused)
5228 int effect_type, effect_flag;
5229 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
5230 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
5233 static inline int get_fp_val(GetBitContext* gb)
5235 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
5238 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
5242 switch (get_bits(gb, 2)) {
5245 c[2] = get_fp_val(gb);
5249 c[0] = c[4] = get_fp_val(gb);
5250 c[2] = get_fp_val(gb);
5253 c[0] = get_fp_val(gb);
5254 c[2] = get_fp_val(gb);
5255 c[4] = get_fp_val(gb);
5258 c[0] = get_fp_val(gb);
5259 c[1] = get_fp_val(gb);
5260 c[2] = get_fp_val(gb);
5261 c[3] = get_fp_val(gb);
5262 c[4] = get_fp_val(gb);
5265 c[5] = get_fp_val(gb);
5267 c[6] = get_fp_val(gb);
5272 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
5274 AVCodecContext *avctx = v->s.avctx;
5277 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5278 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
5279 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
5280 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
5281 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
5282 for (i = 0; i < 7; i++)
5283 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
5284 sd->coefs[sprite][i] / (1<<16),
5285 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
5286 av_log(avctx, AV_LOG_DEBUG, "\n");
5290 if (sd->effect_type = get_bits_long(gb, 30)) {
5291 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
5293 vc1_sprite_parse_transform(gb, sd->effect_params1);
5296 vc1_sprite_parse_transform(gb, sd->effect_params1);
5297 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
5300 for (i = 0; i < sd->effect_pcount1; i++)
5301 sd->effect_params1[i] = get_fp_val(gb);
5303 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
5304 // effect 13 is simple alpha blending and matches the opacity above
5305 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
5306 for (i = 0; i < sd->effect_pcount1; i++)
5307 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5308 sd->effect_params1[i] / (1 << 16),
5309 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
5310 av_log(avctx, AV_LOG_DEBUG, "\n");
5313 sd->effect_pcount2 = get_bits(gb, 16);
5314 if (sd->effect_pcount2 > 10) {
5315 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
5317 } else if (sd->effect_pcount2) {
5319 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
5320 while (++i < sd->effect_pcount2) {
5321 sd->effect_params2[i] = get_fp_val(gb);
5322 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5323 sd->effect_params2[i] / (1 << 16),
5324 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
5326 av_log(avctx, AV_LOG_DEBUG, "\n");
5329 if (sd->effect_flag = get_bits1(gb))
5330 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
5332 if (get_bits_count(gb) >= gb->size_in_bits +
5333 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
5334 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
5335 if (get_bits_count(gb) < gb->size_in_bits - 8)
5336 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
5339 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
5341 int i, plane, row, sprite;
5342 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
5343 uint8_t* src_h[2][2];
5344 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
5346 MpegEncContext *s = &v->s;
5348 for (i = 0; i < 2; i++) {
5349 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
5350 xadv[i] = sd->coefs[i][0];
5351 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
5352 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
5354 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
5355 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
5357 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
5359 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
5360 int width = v->output_width>>!!plane;
5362 for (row = 0; row < v->output_height>>!!plane; row++) {
5363 uint8_t *dst = v->sprite_output_frame.data[plane] +
5364 v->sprite_output_frame.linesize[plane] * row;
5366 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5367 uint8_t *iplane = s->current_picture.f.data[plane];
5368 int iline = s->current_picture.f.linesize[plane];
5369 int ycoord = yoff[sprite] + yadv[sprite] * row;
5370 int yline = ycoord >> 16;
5372 ysub[sprite] = ycoord & 0xFFFF;
5374 iplane = s->last_picture.f.data[plane];
5375 iline = s->last_picture.f.linesize[plane];
5377 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
5378 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
5379 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
5381 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
5383 if (sr_cache[sprite][0] != yline) {
5384 if (sr_cache[sprite][1] == yline) {
5385 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
5386 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
5388 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
5389 sr_cache[sprite][0] = yline;
5392 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
5393 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
5394 iplane + next_line, xoff[sprite],
5395 xadv[sprite], width);
5396 sr_cache[sprite][1] = yline + 1;
5398 src_h[sprite][0] = v->sr_rows[sprite][0];
5399 src_h[sprite][1] = v->sr_rows[sprite][1];
5403 if (!v->two_sprites) {
5405 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
5407 memcpy(dst, src_h[0][0], width);
5410 if (ysub[0] && ysub[1]) {
5411 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5412 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5413 } else if (ysub[0]) {
5414 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5415 src_h[1][0], alpha, width);
5416 } else if (ysub[1]) {
5417 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5418 src_h[0][0], (1<<16)-1-alpha, width);
5420 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5426 for (i = 0; i < 2; i++) {
5436 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5439 MpegEncContext *s = &v->s;
5440 AVCodecContext *avctx = s->avctx;
5443 vc1_parse_sprites(v, gb, &sd);
5445 if (!s->current_picture.f.data[0]) {
5446 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5450 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5451 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5455 av_frame_unref(&v->sprite_output_frame);
5456 if ((ret = ff_get_buffer(avctx, &v->sprite_output_frame, 0)) < 0)
5459 vc1_draw_sprites(v, &sd);
5464 static void vc1_sprite_flush(AVCodecContext *avctx)
5466 VC1Context *v = avctx->priv_data;
5467 MpegEncContext *s = &v->s;
5468 AVFrame *f = &s->current_picture.f;
5471 /* Windows Media Image codecs have a convergence interval of two keyframes.
5472 Since we can't enforce it, clear to black the missing sprite. This is
5473 wrong but it looks better than doing nothing. */
5476 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5477 for (i = 0; i < v->sprite_height>>!!plane; i++)
5478 memset(f->data[plane] + i * f->linesize[plane],
5479 plane ? 128 : 0, f->linesize[plane]);
5484 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5486 MpegEncContext *s = &v->s;
5489 /* Allocate mb bitplanes */
5490 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5491 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5492 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5493 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5494 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5495 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5497 v->n_allocated_blks = s->mb_width + 2;
5498 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5499 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5500 v->cbp = v->cbp_base + s->mb_stride;
5501 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5502 v->ttblk = v->ttblk_base + s->mb_stride;
5503 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5504 v->is_intra = v->is_intra_base + s->mb_stride;
5505 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5506 v->luma_mv = v->luma_mv_base + s->mb_stride;
5508 /* allocate block type info in that way so it could be used with s->block_index[] */
5509 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5510 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5511 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5512 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5514 /* allocate memory to store block level MV info */
5515 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5516 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5517 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5518 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5519 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5520 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5521 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5522 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5524 /* Init coded blocks info */
5525 if (v->profile == PROFILE_ADVANCED) {
5526 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5528 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5532 ff_intrax8_common_init(&v->x8,s);
5534 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5535 for (i = 0; i < 4; i++)
5536 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5539 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5540 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5547 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5550 for (i = 0; i < 64; i++) {
5551 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5552 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5553 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5554 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5555 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5556 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5562 /** Initialize a VC1/WMV3 decoder
5563 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5564 * @todo TODO: Decypher remaining bits in extra_data
5566 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5568 VC1Context *v = avctx->priv_data;
5569 MpegEncContext *s = &v->s;
5572 /* save the container output size for WMImage */
5573 v->output_width = avctx->width;
5574 v->output_height = avctx->height;
5576 if (!avctx->extradata_size || !avctx->extradata)
5578 if (!(avctx->flags & CODEC_FLAG_GRAY))
5579 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5581 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5582 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5584 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5585 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5587 if (ff_vc1_init_common(v) < 0)
5589 // ensure static VLC tables are initialized
5590 if (ff_msmpeg4_decode_init(avctx) < 0)
5592 if (ff_vc1_decode_init_alloc_tables(v) < 0)
5594 // Hack to ensure the above functions will be called
5595 // again once we know all necessary settings.
5596 // That this is necessary might indicate a bug.
5597 ff_vc1_decode_end(avctx);
5599 ff_h264chroma_init(&v->h264chroma, 8);
5600 ff_vc1dsp_init(&v->vc1dsp);
5602 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5605 // looks like WMV3 has a sequence header stored in the extradata
5606 // advanced sequence header may be before the first frame
5607 // the last byte of the extradata is a version number, 1 for the
5608 // samples we can decode
5610 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5612 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5615 count = avctx->extradata_size*8 - get_bits_count(&gb);
5617 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5618 count, get_bits(&gb, count));
5619 } else if (count < 0) {
5620 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5622 } else { // VC1/WVC1/WVP2
5623 const uint8_t *start = avctx->extradata;
5624 uint8_t *end = avctx->extradata + avctx->extradata_size;
5625 const uint8_t *next;
5626 int size, buf2_size;
5627 uint8_t *buf2 = NULL;
5628 int seq_initialized = 0, ep_initialized = 0;
5630 if (avctx->extradata_size < 16) {
5631 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5635 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5636 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5638 for (; next < end; start = next) {
5639 next = find_next_marker(start + 4, end);
5640 size = next - start - 4;
5643 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5644 init_get_bits(&gb, buf2, buf2_size * 8);
5645 switch (AV_RB32(start)) {
5646 case VC1_CODE_SEQHDR:
5647 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5651 seq_initialized = 1;
5653 case VC1_CODE_ENTRYPOINT:
5654 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5663 if (!seq_initialized || !ep_initialized) {
5664 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5667 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5670 avctx->profile = v->profile;
5671 if (v->profile == PROFILE_ADVANCED)
5672 avctx->level = v->level;
5674 avctx->has_b_frames = !!avctx->max_b_frames;
5676 s->mb_width = (avctx->coded_width + 15) >> 4;
5677 s->mb_height = (avctx->coded_height + 15) >> 4;
5679 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5680 ff_vc1_init_transposed_scantables(v);
5682 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5687 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5688 v->sprite_width = avctx->coded_width;
5689 v->sprite_height = avctx->coded_height;
5691 avctx->coded_width = avctx->width = v->output_width;
5692 avctx->coded_height = avctx->height = v->output_height;
5694 // prevent 16.16 overflows
5695 if (v->sprite_width > 1 << 14 ||
5696 v->sprite_height > 1 << 14 ||
5697 v->output_width > 1 << 14 ||
5698 v->output_height > 1 << 14) return -1;
5700 if ((v->sprite_width&1) || (v->sprite_height&1)) {
5701 avpriv_request_sample(avctx, "odd sprites support");
5702 return AVERROR_PATCHWELCOME;
5708 /** Close a VC1/WMV3 decoder
5709 * @warning Initial try at using MpegEncContext stuff
5711 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5713 VC1Context *v = avctx->priv_data;
5716 av_frame_unref(&v->sprite_output_frame);
5718 for (i = 0; i < 4; i++)
5719 av_freep(&v->sr_rows[i >> 1][i & 1]);
5720 av_freep(&v->hrd_rate);
5721 av_freep(&v->hrd_buffer);
5722 ff_MPV_common_end(&v->s);
5723 av_freep(&v->mv_type_mb_plane);
5724 av_freep(&v->direct_mb_plane);
5725 av_freep(&v->forward_mb_plane);
5726 av_freep(&v->fieldtx_plane);
5727 av_freep(&v->acpred_plane);
5728 av_freep(&v->over_flags_plane);
5729 av_freep(&v->mb_type_base);
5730 av_freep(&v->blk_mv_type_base);
5731 av_freep(&v->mv_f_base);
5732 av_freep(&v->mv_f_next_base);
5733 av_freep(&v->block);
5734 av_freep(&v->cbp_base);
5735 av_freep(&v->ttblk_base);
5736 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5737 av_freep(&v->luma_mv_base);
5738 ff_intrax8_common_end(&v->x8);
5743 /** Decode a VC1/WMV3 frame
5744 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5746 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5747 int *got_frame, AVPacket *avpkt)
5749 const uint8_t *buf = avpkt->data;
5750 int buf_size = avpkt->size, n_slices = 0, i, ret;
5751 VC1Context *v = avctx->priv_data;
5752 MpegEncContext *s = &v->s;
5753 AVFrame *pict = data;
5754 uint8_t *buf2 = NULL;
5755 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
5756 int mb_height, n_slices1=-1;
5761 } *slices = NULL, *tmp;
5763 v->second_field = 0;
5765 if(s->flags & CODEC_FLAG_LOW_DELAY)
5768 /* no supplementary picture */
5769 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5770 /* special case for last picture */
5771 if (s->low_delay == 0 && s->next_picture_ptr) {
5772 if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
5774 s->next_picture_ptr = NULL;
5782 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5783 if (v->profile < PROFILE_ADVANCED)
5784 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5786 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5789 //for advanced profile we may need to parse and unescape data
5790 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5792 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5794 return AVERROR(ENOMEM);
5796 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5797 const uint8_t *start, *end, *next;
5801 for (start = buf, end = buf + buf_size; next < end; start = next) {
5802 next = find_next_marker(start + 4, end);
5803 size = next - start - 4;
5804 if (size <= 0) continue;
5805 switch (AV_RB32(start)) {
5806 case VC1_CODE_FRAME:
5807 if (avctx->hwaccel ||
5808 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5810 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5812 case VC1_CODE_FIELD: {
5814 if (avctx->hwaccel ||
5815 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5816 buf_start_second_field = start;
5817 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5821 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5822 if (!slices[n_slices].buf)
5824 buf_size3 = vc1_unescape_buffer(start + 4, size,
5825 slices[n_slices].buf);
5826 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5828 /* assuming that the field marker is at the exact middle,
5829 hope it's correct */
5830 slices[n_slices].mby_start = s->mb_height >> 1;
5831 n_slices1 = n_slices - 1; // index of the last slice of the first field
5835 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5836 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5837 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5838 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5840 case VC1_CODE_SLICE: {
5842 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5846 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5847 if (!slices[n_slices].buf)
5849 buf_size3 = vc1_unescape_buffer(start + 4, size,
5850 slices[n_slices].buf);
5851 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5853 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5859 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5860 const uint8_t *divider;
5863 divider = find_next_marker(buf, buf + buf_size);
5864 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5865 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5867 } else { // found field marker, unescape second field
5868 if (avctx->hwaccel ||
5869 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5870 buf_start_second_field = divider;
5871 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5875 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5876 if (!slices[n_slices].buf)
5878 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5879 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5881 slices[n_slices].mby_start = s->mb_height >> 1;
5882 n_slices1 = n_slices - 1;
5885 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5887 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5889 init_get_bits(&s->gb, buf2, buf_size2*8);
5891 init_get_bits(&s->gb, buf, buf_size*8);
5893 if (v->res_sprite) {
5894 v->new_sprite = !get_bits1(&s->gb);
5895 v->two_sprites = get_bits1(&s->gb);
5896 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5897 we're using the sprite compositor. These are intentionally kept separate
5898 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5899 the vc1 one for WVP2 */
5900 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5901 if (v->new_sprite) {
5902 // switch AVCodecContext parameters to those of the sprites
5903 avctx->width = avctx->coded_width = v->sprite_width;
5904 avctx->height = avctx->coded_height = v->sprite_height;
5911 if (s->context_initialized &&
5912 (s->width != avctx->coded_width ||
5913 s->height != avctx->coded_height)) {
5914 ff_vc1_decode_end(avctx);
5917 if (!s->context_initialized) {
5918 if (ff_msmpeg4_decode_init(avctx) < 0 || ff_vc1_decode_init_alloc_tables(v) < 0)
5921 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5923 if (v->profile == PROFILE_ADVANCED) {
5924 if(avctx->coded_width<=1 || avctx->coded_height<=1)
5926 s->h_edge_pos = avctx->coded_width;
5927 s->v_edge_pos = avctx->coded_height;
5931 /* We need to set current_picture_ptr before reading the header,
5932 * otherwise we cannot store anything in there. */
5933 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5934 int i = ff_find_unused_picture(s, 0);
5937 s->current_picture_ptr = &s->picture[i];
5940 // do parse frame header
5941 v->pic_header_flag = 0;
5942 v->first_pic_header_flag = 1;
5943 if (v->profile < PROFILE_ADVANCED) {
5944 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5948 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5952 v->first_pic_header_flag = 0;
5954 if (avctx->debug & FF_DEBUG_PICT_INFO)
5955 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
5957 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5958 && s->pict_type != AV_PICTURE_TYPE_I) {
5959 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5963 if ((s->mb_height >> v->field_mode) == 0) {
5964 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
5968 // process pulldown flags
5969 s->current_picture_ptr->f.repeat_pict = 0;
5970 // Pulldown flags are only valid when 'broadcast' has been set.
5971 // So ticks_per_frame will be 2
5974 s->current_picture_ptr->f.repeat_pict = 1;
5975 } else if (v->rptfrm) {
5977 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5980 // for skipping the frame
5981 s->current_picture.f.pict_type = s->pict_type;
5982 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5984 /* skip B-frames if we don't have reference frames */
5985 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
5988 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5989 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5990 avctx->skip_frame >= AVDISCARD_ALL) {
5994 if (s->next_p_frame_damaged) {
5995 if (s->pict_type == AV_PICTURE_TYPE_B)
5998 s->next_p_frame_damaged = 0;
6001 if (ff_MPV_frame_start(s, avctx) < 0) {
6005 v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
6006 v->s.current_picture_ptr->f.top_field_first = v->tff;
6008 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
6009 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
6011 if ((CONFIG_VC1_VDPAU_DECODER)
6012 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
6013 if (v->field_mode && buf_start_second_field) {
6014 ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
6015 ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
6017 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
6019 } else if (avctx->hwaccel) {
6020 if (v->field_mode && buf_start_second_field) {
6021 // decode first field
6022 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
6023 if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6025 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6027 if (avctx->hwaccel->end_frame(avctx) < 0)
6030 // decode second field
6031 s->gb = slices[n_slices1 + 1].gb;
6032 s->picture_structure = PICT_TOP_FIELD + v->tff;
6033 v->second_field = 1;
6034 v->pic_header_flag = 0;
6035 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
6036 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
6039 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
6041 if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6043 if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6045 if (avctx->hwaccel->end_frame(avctx) < 0)
6048 s->picture_structure = PICT_FRAME;
6049 if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6051 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6053 if (avctx->hwaccel->end_frame(avctx) < 0)
6060 ff_mpeg_er_frame_start(s);
6062 v->bits = buf_size * 8;
6063 v->end_mb_x = s->mb_width;
6064 if (v->field_mode) {
6065 s->current_picture.f.linesize[0] <<= 1;
6066 s->current_picture.f.linesize[1] <<= 1;
6067 s->current_picture.f.linesize[2] <<= 1;
6069 s->uvlinesize <<= 1;
6071 mb_height = s->mb_height >> v->field_mode;
6073 av_assert0 (mb_height > 0);
6075 for (i = 0; i <= n_slices; i++) {
6076 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
6077 if (v->field_mode <= 0) {
6078 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
6079 "picture boundary (%d >= %d)\n", i,
6080 slices[i - 1].mby_start, mb_height);
6083 v->second_field = 1;
6084 v->blocks_off = s->b8_stride * (s->mb_height&~1);
6085 v->mb_off = s->mb_stride * s->mb_height >> 1;
6087 v->second_field = 0;
6092 v->pic_header_flag = 0;
6093 if (v->field_mode && i == n_slices1 + 2) {
6094 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6095 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
6098 } else if (get_bits1(&s->gb)) {
6099 v->pic_header_flag = 1;
6100 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6101 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
6108 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
6109 if (!v->field_mode || v->second_field)
6110 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6112 if (i >= n_slices) {
6113 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
6116 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6118 if (s->end_mb_y <= s->start_mb_y) {
6119 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
6122 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
6123 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
6126 ff_vc1_decode_blocks(v);
6128 s->gb = slices[i].gb;
6130 if (v->field_mode) {
6131 v->second_field = 0;
6132 s->current_picture.f.linesize[0] >>= 1;
6133 s->current_picture.f.linesize[1] >>= 1;
6134 s->current_picture.f.linesize[2] >>= 1;
6136 s->uvlinesize >>= 1;
6137 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
6138 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
6139 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
6142 av_dlog(s->avctx, "Consumed %i/%i bits\n",
6143 get_bits_count(&s->gb), s->gb.size_in_bits);
6144 // if (get_bits_count(&s->gb) > buf_size * 8)
6146 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
6149 ff_er_frame_end(&s->er);
6152 ff_MPV_frame_end(s);
6154 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
6156 avctx->width = avctx->coded_width = v->output_width;
6157 avctx->height = avctx->coded_height = v->output_height;
6158 if (avctx->skip_frame >= AVDISCARD_NONREF)
6160 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
6161 if (vc1_decode_sprites(v, &s->gb))
6164 if ((ret = av_frame_ref(pict, &v->sprite_output_frame)) < 0)
6168 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
6169 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
6171 ff_print_debug_info(s, s->current_picture_ptr, pict);
6172 } else if (s->last_picture_ptr != NULL) {
6173 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
6175 ff_print_debug_info(s, s->last_picture_ptr, pict);
6177 if (s->last_picture_ptr || s->low_delay) {
6184 for (i = 0; i < n_slices; i++)
6185 av_free(slices[i].buf);
6191 for (i = 0; i < n_slices; i++)
6192 av_free(slices[i].buf);
6198 static const AVProfile profiles[] = {
6199 { FF_PROFILE_VC1_SIMPLE, "Simple" },
6200 { FF_PROFILE_VC1_MAIN, "Main" },
6201 { FF_PROFILE_VC1_COMPLEX, "Complex" },
6202 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
6203 { FF_PROFILE_UNKNOWN },
6206 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
6208 AV_PIX_FMT_DXVA2_VLD,
6211 AV_PIX_FMT_VAAPI_VLD,
6220 AVCodec ff_vc1_decoder = {
6222 .type = AVMEDIA_TYPE_VIDEO,
6223 .id = AV_CODEC_ID_VC1,
6224 .priv_data_size = sizeof(VC1Context),
6225 .init = vc1_decode_init,
6226 .close = ff_vc1_decode_end,
6227 .decode = vc1_decode_frame,
6228 .flush = ff_mpeg_flush,
6229 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6230 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
6231 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6232 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6235 #if CONFIG_WMV3_DECODER
6236 AVCodec ff_wmv3_decoder = {
6238 .type = AVMEDIA_TYPE_VIDEO,
6239 .id = AV_CODEC_ID_WMV3,
6240 .priv_data_size = sizeof(VC1Context),
6241 .init = vc1_decode_init,
6242 .close = ff_vc1_decode_end,
6243 .decode = vc1_decode_frame,
6244 .flush = ff_mpeg_flush,
6245 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6246 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
6247 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6248 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6252 #if CONFIG_WMV3_VDPAU_DECODER
6253 AVCodec ff_wmv3_vdpau_decoder = {
6254 .name = "wmv3_vdpau",
6255 .type = AVMEDIA_TYPE_VIDEO,
6256 .id = AV_CODEC_ID_WMV3,
6257 .priv_data_size = sizeof(VC1Context),
6258 .init = vc1_decode_init,
6259 .close = ff_vc1_decode_end,
6260 .decode = vc1_decode_frame,
6261 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6262 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
6263 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
6264 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6268 #if CONFIG_VC1_VDPAU_DECODER
6269 AVCodec ff_vc1_vdpau_decoder = {
6270 .name = "vc1_vdpau",
6271 .type = AVMEDIA_TYPE_VIDEO,
6272 .id = AV_CODEC_ID_VC1,
6273 .priv_data_size = sizeof(VC1Context),
6274 .init = vc1_decode_init,
6275 .close = ff_vc1_decode_end,
6276 .decode = vc1_decode_frame,
6277 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6278 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
6279 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
6280 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6284 #if CONFIG_WMV3IMAGE_DECODER
6285 AVCodec ff_wmv3image_decoder = {
6286 .name = "wmv3image",
6287 .type = AVMEDIA_TYPE_VIDEO,
6288 .id = AV_CODEC_ID_WMV3IMAGE,
6289 .priv_data_size = sizeof(VC1Context),
6290 .init = vc1_decode_init,
6291 .close = ff_vc1_decode_end,
6292 .decode = vc1_decode_frame,
6293 .capabilities = CODEC_CAP_DR1,
6294 .flush = vc1_sprite_flush,
6295 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
6296 .pix_fmts = ff_pixfmt_list_420
6300 #if CONFIG_VC1IMAGE_DECODER
6301 AVCodec ff_vc1image_decoder = {
6303 .type = AVMEDIA_TYPE_VIDEO,
6304 .id = AV_CODEC_ID_VC1IMAGE,
6305 .priv_data_size = sizeof(VC1Context),
6306 .init = vc1_decode_init,
6307 .close = ff_vc1_decode_end,
6308 .decode = vc1_decode_frame,
6309 .capabilities = CODEC_CAP_DR1,
6310 .flush = vc1_sprite_flush,
6311 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
6312 .pix_fmts = ff_pixfmt_list_420