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 if (!v->s.last_picture.f.data[0])
5161 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
5162 s->first_slice_line = 1;
5163 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5165 init_block_index(v);
5166 ff_update_block_index(s);
5167 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
5168 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5169 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5170 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5171 s->first_slice_line = 0;
5173 s->pict_type = AV_PICTURE_TYPE_P;
5176 void ff_vc1_decode_blocks(VC1Context *v)
5179 v->s.esc3_level_length = 0;
5181 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
5184 v->left_blk_idx = -1;
5185 v->topleft_blk_idx = 1;
5187 switch (v->s.pict_type) {
5188 case AV_PICTURE_TYPE_I:
5189 if (v->profile == PROFILE_ADVANCED)
5190 vc1_decode_i_blocks_adv(v);
5192 vc1_decode_i_blocks(v);
5194 case AV_PICTURE_TYPE_P:
5195 if (v->p_frame_skipped)
5196 vc1_decode_skip_blocks(v);
5198 vc1_decode_p_blocks(v);
5200 case AV_PICTURE_TYPE_B:
5202 if (v->profile == PROFILE_ADVANCED)
5203 vc1_decode_i_blocks_adv(v);
5205 vc1_decode_i_blocks(v);
5207 vc1_decode_b_blocks(v);
5213 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5217 * Transform coefficients for both sprites in 16.16 fixed point format,
5218 * in the order they appear in the bitstream:
5220 * rotation 1 (unused)
5222 * rotation 2 (unused)
5229 int effect_type, effect_flag;
5230 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
5231 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
5234 static inline int get_fp_val(GetBitContext* gb)
5236 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
5239 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
5243 switch (get_bits(gb, 2)) {
5246 c[2] = get_fp_val(gb);
5250 c[0] = c[4] = get_fp_val(gb);
5251 c[2] = get_fp_val(gb);
5254 c[0] = get_fp_val(gb);
5255 c[2] = get_fp_val(gb);
5256 c[4] = get_fp_val(gb);
5259 c[0] = get_fp_val(gb);
5260 c[1] = get_fp_val(gb);
5261 c[2] = get_fp_val(gb);
5262 c[3] = get_fp_val(gb);
5263 c[4] = get_fp_val(gb);
5266 c[5] = get_fp_val(gb);
5268 c[6] = get_fp_val(gb);
5273 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
5275 AVCodecContext *avctx = v->s.avctx;
5278 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5279 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
5280 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
5281 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
5282 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
5283 for (i = 0; i < 7; i++)
5284 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
5285 sd->coefs[sprite][i] / (1<<16),
5286 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
5287 av_log(avctx, AV_LOG_DEBUG, "\n");
5291 if (sd->effect_type = get_bits_long(gb, 30)) {
5292 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
5294 vc1_sprite_parse_transform(gb, sd->effect_params1);
5297 vc1_sprite_parse_transform(gb, sd->effect_params1);
5298 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
5301 for (i = 0; i < sd->effect_pcount1; i++)
5302 sd->effect_params1[i] = get_fp_val(gb);
5304 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
5305 // effect 13 is simple alpha blending and matches the opacity above
5306 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
5307 for (i = 0; i < sd->effect_pcount1; i++)
5308 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5309 sd->effect_params1[i] / (1 << 16),
5310 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
5311 av_log(avctx, AV_LOG_DEBUG, "\n");
5314 sd->effect_pcount2 = get_bits(gb, 16);
5315 if (sd->effect_pcount2 > 10) {
5316 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
5318 } else if (sd->effect_pcount2) {
5320 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
5321 while (++i < sd->effect_pcount2) {
5322 sd->effect_params2[i] = get_fp_val(gb);
5323 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5324 sd->effect_params2[i] / (1 << 16),
5325 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
5327 av_log(avctx, AV_LOG_DEBUG, "\n");
5330 if (sd->effect_flag = get_bits1(gb))
5331 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
5333 if (get_bits_count(gb) >= gb->size_in_bits +
5334 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
5335 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
5336 if (get_bits_count(gb) < gb->size_in_bits - 8)
5337 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
5340 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
5342 int i, plane, row, sprite;
5343 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
5344 uint8_t* src_h[2][2];
5345 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
5347 MpegEncContext *s = &v->s;
5349 for (i = 0; i < 2; i++) {
5350 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
5351 xadv[i] = sd->coefs[i][0];
5352 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
5353 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
5355 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
5356 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
5358 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
5360 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
5361 int width = v->output_width>>!!plane;
5363 for (row = 0; row < v->output_height>>!!plane; row++) {
5364 uint8_t *dst = v->sprite_output_frame.data[plane] +
5365 v->sprite_output_frame.linesize[plane] * row;
5367 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5368 uint8_t *iplane = s->current_picture.f.data[plane];
5369 int iline = s->current_picture.f.linesize[plane];
5370 int ycoord = yoff[sprite] + yadv[sprite] * row;
5371 int yline = ycoord >> 16;
5373 ysub[sprite] = ycoord & 0xFFFF;
5375 iplane = s->last_picture.f.data[plane];
5376 iline = s->last_picture.f.linesize[plane];
5378 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
5379 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
5380 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
5382 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
5384 if (sr_cache[sprite][0] != yline) {
5385 if (sr_cache[sprite][1] == yline) {
5386 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
5387 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
5389 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
5390 sr_cache[sprite][0] = yline;
5393 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
5394 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
5395 iplane + next_line, xoff[sprite],
5396 xadv[sprite], width);
5397 sr_cache[sprite][1] = yline + 1;
5399 src_h[sprite][0] = v->sr_rows[sprite][0];
5400 src_h[sprite][1] = v->sr_rows[sprite][1];
5404 if (!v->two_sprites) {
5406 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
5408 memcpy(dst, src_h[0][0], width);
5411 if (ysub[0] && ysub[1]) {
5412 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5413 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5414 } else if (ysub[0]) {
5415 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5416 src_h[1][0], alpha, width);
5417 } else if (ysub[1]) {
5418 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5419 src_h[0][0], (1<<16)-1-alpha, width);
5421 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5427 for (i = 0; i < 2; i++) {
5437 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5440 MpegEncContext *s = &v->s;
5441 AVCodecContext *avctx = s->avctx;
5444 vc1_parse_sprites(v, gb, &sd);
5446 if (!s->current_picture.f.data[0]) {
5447 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5451 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5452 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5456 av_frame_unref(&v->sprite_output_frame);
5457 if ((ret = ff_get_buffer(avctx, &v->sprite_output_frame, 0)) < 0)
5460 vc1_draw_sprites(v, &sd);
5465 static void vc1_sprite_flush(AVCodecContext *avctx)
5467 VC1Context *v = avctx->priv_data;
5468 MpegEncContext *s = &v->s;
5469 AVFrame *f = &s->current_picture.f;
5472 /* Windows Media Image codecs have a convergence interval of two keyframes.
5473 Since we can't enforce it, clear to black the missing sprite. This is
5474 wrong but it looks better than doing nothing. */
5477 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5478 for (i = 0; i < v->sprite_height>>!!plane; i++)
5479 memset(f->data[plane] + i * f->linesize[plane],
5480 plane ? 128 : 0, f->linesize[plane]);
5485 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5487 MpegEncContext *s = &v->s;
5490 /* Allocate mb bitplanes */
5491 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5492 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5493 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5494 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5495 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5496 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5498 v->n_allocated_blks = s->mb_width + 2;
5499 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5500 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5501 v->cbp = v->cbp_base + s->mb_stride;
5502 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5503 v->ttblk = v->ttblk_base + s->mb_stride;
5504 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5505 v->is_intra = v->is_intra_base + s->mb_stride;
5506 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5507 v->luma_mv = v->luma_mv_base + s->mb_stride;
5509 /* allocate block type info in that way so it could be used with s->block_index[] */
5510 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5511 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5512 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5513 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5515 /* allocate memory to store block level MV info */
5516 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5517 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5518 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5519 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5520 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5521 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5522 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5523 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);
5525 /* Init coded blocks info */
5526 if (v->profile == PROFILE_ADVANCED) {
5527 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5529 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5533 ff_intrax8_common_init(&v->x8,s);
5535 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5536 for (i = 0; i < 4; i++)
5537 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
5538 return AVERROR(ENOMEM);
5541 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5542 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5544 av_freep(&v->mv_type_mb_plane);
5545 av_freep(&v->direct_mb_plane);
5546 av_freep(&v->acpred_plane);
5547 av_freep(&v->over_flags_plane);
5548 av_freep(&v->block);
5549 av_freep(&v->cbp_base);
5550 av_freep(&v->ttblk_base);
5551 av_freep(&v->is_intra_base);
5552 av_freep(&v->luma_mv_base);
5553 av_freep(&v->mb_type_base);
5554 return AVERROR(ENOMEM);
5560 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5563 for (i = 0; i < 64; i++) {
5564 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5565 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5566 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5567 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5568 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5569 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5575 /** Initialize a VC1/WMV3 decoder
5576 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5577 * @todo TODO: Decypher remaining bits in extra_data
5579 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5581 VC1Context *v = avctx->priv_data;
5582 MpegEncContext *s = &v->s;
5586 /* save the container output size for WMImage */
5587 v->output_width = avctx->width;
5588 v->output_height = avctx->height;
5590 if (!avctx->extradata_size || !avctx->extradata)
5592 if (!(avctx->flags & CODEC_FLAG_GRAY))
5593 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5595 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5596 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5598 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5599 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5601 if ((ret = ff_vc1_init_common(v)) < 0)
5603 // ensure static VLC tables are initialized
5604 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
5606 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
5608 // Hack to ensure the above functions will be called
5609 // again once we know all necessary settings.
5610 // That this is necessary might indicate a bug.
5611 ff_vc1_decode_end(avctx);
5613 ff_h264chroma_init(&v->h264chroma, 8);
5614 ff_vc1dsp_init(&v->vc1dsp);
5616 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5619 // looks like WMV3 has a sequence header stored in the extradata
5620 // advanced sequence header may be before the first frame
5621 // the last byte of the extradata is a version number, 1 for the
5622 // samples we can decode
5624 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5626 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
5629 count = avctx->extradata_size*8 - get_bits_count(&gb);
5631 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5632 count, get_bits(&gb, count));
5633 } else if (count < 0) {
5634 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5636 } else { // VC1/WVC1/WVP2
5637 const uint8_t *start = avctx->extradata;
5638 uint8_t *end = avctx->extradata + avctx->extradata_size;
5639 const uint8_t *next;
5640 int size, buf2_size;
5641 uint8_t *buf2 = NULL;
5642 int seq_initialized = 0, ep_initialized = 0;
5644 if (avctx->extradata_size < 16) {
5645 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5649 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5650 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5652 for (; next < end; start = next) {
5653 next = find_next_marker(start + 4, end);
5654 size = next - start - 4;
5657 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5658 init_get_bits(&gb, buf2, buf2_size * 8);
5659 switch (AV_RB32(start)) {
5660 case VC1_CODE_SEQHDR:
5661 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
5665 seq_initialized = 1;
5667 case VC1_CODE_ENTRYPOINT:
5668 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
5677 if (!seq_initialized || !ep_initialized) {
5678 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5681 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5684 avctx->profile = v->profile;
5685 if (v->profile == PROFILE_ADVANCED)
5686 avctx->level = v->level;
5688 avctx->has_b_frames = !!avctx->max_b_frames;
5690 s->mb_width = (avctx->coded_width + 15) >> 4;
5691 s->mb_height = (avctx->coded_height + 15) >> 4;
5693 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5694 ff_vc1_init_transposed_scantables(v);
5696 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5701 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5702 v->sprite_width = avctx->coded_width;
5703 v->sprite_height = avctx->coded_height;
5705 avctx->coded_width = avctx->width = v->output_width;
5706 avctx->coded_height = avctx->height = v->output_height;
5708 // prevent 16.16 overflows
5709 if (v->sprite_width > 1 << 14 ||
5710 v->sprite_height > 1 << 14 ||
5711 v->output_width > 1 << 14 ||
5712 v->output_height > 1 << 14) return -1;
5714 if ((v->sprite_width&1) || (v->sprite_height&1)) {
5715 avpriv_request_sample(avctx, "odd sprites support");
5716 return AVERROR_PATCHWELCOME;
5722 /** Close a VC1/WMV3 decoder
5723 * @warning Initial try at using MpegEncContext stuff
5725 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5727 VC1Context *v = avctx->priv_data;
5730 av_frame_unref(&v->sprite_output_frame);
5732 for (i = 0; i < 4; i++)
5733 av_freep(&v->sr_rows[i >> 1][i & 1]);
5734 av_freep(&v->hrd_rate);
5735 av_freep(&v->hrd_buffer);
5736 ff_MPV_common_end(&v->s);
5737 av_freep(&v->mv_type_mb_plane);
5738 av_freep(&v->direct_mb_plane);
5739 av_freep(&v->forward_mb_plane);
5740 av_freep(&v->fieldtx_plane);
5741 av_freep(&v->acpred_plane);
5742 av_freep(&v->over_flags_plane);
5743 av_freep(&v->mb_type_base);
5744 av_freep(&v->blk_mv_type_base);
5745 av_freep(&v->mv_f_base);
5746 av_freep(&v->mv_f_next_base);
5747 av_freep(&v->block);
5748 av_freep(&v->cbp_base);
5749 av_freep(&v->ttblk_base);
5750 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5751 av_freep(&v->luma_mv_base);
5752 ff_intrax8_common_end(&v->x8);
5757 /** Decode a VC1/WMV3 frame
5758 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5760 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5761 int *got_frame, AVPacket *avpkt)
5763 const uint8_t *buf = avpkt->data;
5764 int buf_size = avpkt->size, n_slices = 0, i, ret;
5765 VC1Context *v = avctx->priv_data;
5766 MpegEncContext *s = &v->s;
5767 AVFrame *pict = data;
5768 uint8_t *buf2 = NULL;
5769 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
5770 int mb_height, n_slices1=-1;
5775 } *slices = NULL, *tmp;
5777 v->second_field = 0;
5779 if(s->flags & CODEC_FLAG_LOW_DELAY)
5782 /* no supplementary picture */
5783 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5784 /* special case for last picture */
5785 if (s->low_delay == 0 && s->next_picture_ptr) {
5786 if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
5788 s->next_picture_ptr = NULL;
5796 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5797 if (v->profile < PROFILE_ADVANCED)
5798 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5800 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5803 //for advanced profile we may need to parse and unescape data
5804 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5806 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5808 return AVERROR(ENOMEM);
5810 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5811 const uint8_t *start, *end, *next;
5815 for (start = buf, end = buf + buf_size; next < end; start = next) {
5816 next = find_next_marker(start + 4, end);
5817 size = next - start - 4;
5818 if (size <= 0) continue;
5819 switch (AV_RB32(start)) {
5820 case VC1_CODE_FRAME:
5821 if (avctx->hwaccel ||
5822 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5824 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5826 case VC1_CODE_FIELD: {
5828 if (avctx->hwaccel ||
5829 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5830 buf_start_second_field = start;
5831 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5835 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5836 if (!slices[n_slices].buf)
5838 buf_size3 = vc1_unescape_buffer(start + 4, size,
5839 slices[n_slices].buf);
5840 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5842 /* assuming that the field marker is at the exact middle,
5843 hope it's correct */
5844 slices[n_slices].mby_start = s->mb_height >> 1;
5845 n_slices1 = n_slices - 1; // index of the last slice of the first field
5849 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5850 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5851 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5852 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5854 case VC1_CODE_SLICE: {
5856 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5860 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5861 if (!slices[n_slices].buf)
5863 buf_size3 = vc1_unescape_buffer(start + 4, size,
5864 slices[n_slices].buf);
5865 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5867 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5873 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5874 const uint8_t *divider;
5877 divider = find_next_marker(buf, buf + buf_size);
5878 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5879 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5881 } else { // found field marker, unescape second field
5882 if (avctx->hwaccel ||
5883 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5884 buf_start_second_field = divider;
5885 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5889 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5890 if (!slices[n_slices].buf)
5892 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5893 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5895 slices[n_slices].mby_start = s->mb_height >> 1;
5896 n_slices1 = n_slices - 1;
5899 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5901 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5903 init_get_bits(&s->gb, buf2, buf_size2*8);
5905 init_get_bits(&s->gb, buf, buf_size*8);
5907 if (v->res_sprite) {
5908 v->new_sprite = !get_bits1(&s->gb);
5909 v->two_sprites = get_bits1(&s->gb);
5910 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5911 we're using the sprite compositor. These are intentionally kept separate
5912 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5913 the vc1 one for WVP2 */
5914 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5915 if (v->new_sprite) {
5916 // switch AVCodecContext parameters to those of the sprites
5917 avctx->width = avctx->coded_width = v->sprite_width;
5918 avctx->height = avctx->coded_height = v->sprite_height;
5925 if (s->context_initialized &&
5926 (s->width != avctx->coded_width ||
5927 s->height != avctx->coded_height)) {
5928 ff_vc1_decode_end(avctx);
5931 if (!s->context_initialized) {
5932 if (ff_msmpeg4_decode_init(avctx) < 0)
5934 if (ff_vc1_decode_init_alloc_tables(v) < 0) {
5935 ff_MPV_common_end(s);
5939 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5941 if (v->profile == PROFILE_ADVANCED) {
5942 if(avctx->coded_width<=1 || avctx->coded_height<=1)
5944 s->h_edge_pos = avctx->coded_width;
5945 s->v_edge_pos = avctx->coded_height;
5949 /* We need to set current_picture_ptr before reading the header,
5950 * otherwise we cannot store anything in there. */
5951 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5952 int i = ff_find_unused_picture(s, 0);
5955 s->current_picture_ptr = &s->picture[i];
5958 // do parse frame header
5959 v->pic_header_flag = 0;
5960 v->first_pic_header_flag = 1;
5961 if (v->profile < PROFILE_ADVANCED) {
5962 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5966 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5970 v->first_pic_header_flag = 0;
5972 if (avctx->debug & FF_DEBUG_PICT_INFO)
5973 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
5975 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5976 && s->pict_type != AV_PICTURE_TYPE_I) {
5977 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5981 if ((s->mb_height >> v->field_mode) == 0) {
5982 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
5986 // process pulldown flags
5987 s->current_picture_ptr->f.repeat_pict = 0;
5988 // Pulldown flags are only valid when 'broadcast' has been set.
5989 // So ticks_per_frame will be 2
5992 s->current_picture_ptr->f.repeat_pict = 1;
5993 } else if (v->rptfrm) {
5995 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5998 // for skipping the frame
5999 s->current_picture.f.pict_type = s->pict_type;
6000 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
6002 /* skip B-frames if we don't have reference frames */
6003 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
6006 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
6007 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
6008 avctx->skip_frame >= AVDISCARD_ALL) {
6012 if (s->next_p_frame_damaged) {
6013 if (s->pict_type == AV_PICTURE_TYPE_B)
6016 s->next_p_frame_damaged = 0;
6019 if (ff_MPV_frame_start(s, avctx) < 0) {
6023 v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
6024 v->s.current_picture_ptr->f.top_field_first = v->tff;
6026 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
6027 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
6029 if ((CONFIG_VC1_VDPAU_DECODER)
6030 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
6031 if (v->field_mode && buf_start_second_field) {
6032 ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
6033 ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
6035 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
6037 } else if (avctx->hwaccel) {
6038 if (v->field_mode && buf_start_second_field) {
6039 // decode first field
6040 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
6041 if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6043 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6045 if (avctx->hwaccel->end_frame(avctx) < 0)
6048 // decode second field
6049 s->gb = slices[n_slices1 + 1].gb;
6050 s->picture_structure = PICT_TOP_FIELD + v->tff;
6051 v->second_field = 1;
6052 v->pic_header_flag = 0;
6053 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
6054 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
6057 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
6059 if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6061 if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6063 if (avctx->hwaccel->end_frame(avctx) < 0)
6066 s->picture_structure = PICT_FRAME;
6067 if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6069 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6071 if (avctx->hwaccel->end_frame(avctx) < 0)
6077 ff_mpeg_er_frame_start(s);
6079 v->bits = buf_size * 8;
6080 v->end_mb_x = s->mb_width;
6081 if (v->field_mode) {
6082 s->current_picture.f.linesize[0] <<= 1;
6083 s->current_picture.f.linesize[1] <<= 1;
6084 s->current_picture.f.linesize[2] <<= 1;
6086 s->uvlinesize <<= 1;
6088 mb_height = s->mb_height >> v->field_mode;
6090 av_assert0 (mb_height > 0);
6092 for (i = 0; i <= n_slices; i++) {
6093 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
6094 if (v->field_mode <= 0) {
6095 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
6096 "picture boundary (%d >= %d)\n", i,
6097 slices[i - 1].mby_start, mb_height);
6100 v->second_field = 1;
6101 v->blocks_off = s->b8_stride * (s->mb_height&~1);
6102 v->mb_off = s->mb_stride * s->mb_height >> 1;
6104 v->second_field = 0;
6109 v->pic_header_flag = 0;
6110 if (v->field_mode && i == n_slices1 + 2) {
6111 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6112 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
6113 if (avctx->err_recognition & AV_EF_EXPLODE)
6117 } else if (get_bits1(&s->gb)) {
6118 v->pic_header_flag = 1;
6119 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6120 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
6121 if (avctx->err_recognition & AV_EF_EXPLODE)
6129 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
6130 if (!v->field_mode || v->second_field)
6131 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6133 if (i >= n_slices) {
6134 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
6137 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6139 if (s->end_mb_y <= s->start_mb_y) {
6140 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
6143 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
6144 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
6147 ff_vc1_decode_blocks(v);
6149 s->gb = slices[i].gb;
6151 if (v->field_mode) {
6152 v->second_field = 0;
6153 s->current_picture.f.linesize[0] >>= 1;
6154 s->current_picture.f.linesize[1] >>= 1;
6155 s->current_picture.f.linesize[2] >>= 1;
6157 s->uvlinesize >>= 1;
6158 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
6159 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
6160 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
6163 av_dlog(s->avctx, "Consumed %i/%i bits\n",
6164 get_bits_count(&s->gb), s->gb.size_in_bits);
6165 // if (get_bits_count(&s->gb) > buf_size * 8)
6167 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
6170 ff_er_frame_end(&s->er);
6173 ff_MPV_frame_end(s);
6175 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
6177 avctx->width = avctx->coded_width = v->output_width;
6178 avctx->height = avctx->coded_height = v->output_height;
6179 if (avctx->skip_frame >= AVDISCARD_NONREF)
6181 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
6182 if (vc1_decode_sprites(v, &s->gb))
6185 if ((ret = av_frame_ref(pict, &v->sprite_output_frame)) < 0)
6189 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
6190 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
6192 ff_print_debug_info(s, s->current_picture_ptr, pict);
6193 } else if (s->last_picture_ptr != NULL) {
6194 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
6196 ff_print_debug_info(s, s->last_picture_ptr, pict);
6198 if (s->last_picture_ptr || s->low_delay) {
6205 for (i = 0; i < n_slices; i++)
6206 av_free(slices[i].buf);
6212 for (i = 0; i < n_slices; i++)
6213 av_free(slices[i].buf);
6219 static const AVProfile profiles[] = {
6220 { FF_PROFILE_VC1_SIMPLE, "Simple" },
6221 { FF_PROFILE_VC1_MAIN, "Main" },
6222 { FF_PROFILE_VC1_COMPLEX, "Complex" },
6223 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
6224 { FF_PROFILE_UNKNOWN },
6227 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
6229 AV_PIX_FMT_DXVA2_VLD,
6232 AV_PIX_FMT_VAAPI_VLD,
6241 AVCodec ff_vc1_decoder = {
6243 .type = AVMEDIA_TYPE_VIDEO,
6244 .id = AV_CODEC_ID_VC1,
6245 .priv_data_size = sizeof(VC1Context),
6246 .init = vc1_decode_init,
6247 .close = ff_vc1_decode_end,
6248 .decode = vc1_decode_frame,
6249 .flush = ff_mpeg_flush,
6250 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6251 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
6252 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6253 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6256 #if CONFIG_WMV3_DECODER
6257 AVCodec ff_wmv3_decoder = {
6259 .type = AVMEDIA_TYPE_VIDEO,
6260 .id = AV_CODEC_ID_WMV3,
6261 .priv_data_size = sizeof(VC1Context),
6262 .init = vc1_decode_init,
6263 .close = ff_vc1_decode_end,
6264 .decode = vc1_decode_frame,
6265 .flush = ff_mpeg_flush,
6266 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6267 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
6268 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6269 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6273 #if CONFIG_WMV3_VDPAU_DECODER
6274 AVCodec ff_wmv3_vdpau_decoder = {
6275 .name = "wmv3_vdpau",
6276 .type = AVMEDIA_TYPE_VIDEO,
6277 .id = AV_CODEC_ID_WMV3,
6278 .priv_data_size = sizeof(VC1Context),
6279 .init = vc1_decode_init,
6280 .close = ff_vc1_decode_end,
6281 .decode = vc1_decode_frame,
6282 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6283 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
6284 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
6285 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6289 #if CONFIG_VC1_VDPAU_DECODER
6290 AVCodec ff_vc1_vdpau_decoder = {
6291 .name = "vc1_vdpau",
6292 .type = AVMEDIA_TYPE_VIDEO,
6293 .id = AV_CODEC_ID_VC1,
6294 .priv_data_size = sizeof(VC1Context),
6295 .init = vc1_decode_init,
6296 .close = ff_vc1_decode_end,
6297 .decode = vc1_decode_frame,
6298 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6299 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
6300 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
6301 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6305 #if CONFIG_WMV3IMAGE_DECODER
6306 AVCodec ff_wmv3image_decoder = {
6307 .name = "wmv3image",
6308 .type = AVMEDIA_TYPE_VIDEO,
6309 .id = AV_CODEC_ID_WMV3IMAGE,
6310 .priv_data_size = sizeof(VC1Context),
6311 .init = vc1_decode_init,
6312 .close = ff_vc1_decode_end,
6313 .decode = vc1_decode_frame,
6314 .capabilities = CODEC_CAP_DR1,
6315 .flush = vc1_sprite_flush,
6316 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
6317 .pix_fmts = ff_pixfmt_list_420
6321 #if CONFIG_VC1IMAGE_DECODER
6322 AVCodec ff_vc1image_decoder = {
6324 .type = AVMEDIA_TYPE_VIDEO,
6325 .id = AV_CODEC_ID_VC1IMAGE,
6326 .priv_data_size = sizeof(VC1Context),
6327 .init = vc1_decode_init,
6328 .close = ff_vc1_decode_end,
6329 .decode = vc1_decode_frame,
6330 .capabilities = CODEC_CAP_DR1,
6331 .flush = vc1_sprite_flush,
6332 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
6333 .pix_fmts = ff_pixfmt_list_420