2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
32 #include "mpegvideo.h"
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) {
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];
89 /** @} */ //Bitplane group
91 static void vc1_put_signed_blocks_clamped(VC1Context *v)
93 MpegEncContext *s = &v->s;
94 int topleft_mb_pos, top_mb_pos;
95 int stride_y, fieldtx = 0;
98 /* The put pixels loop is always one MB row behind the decoding loop,
99 * because we can only put pixels when overlap filtering is done, and
100 * for filtering of the bottom edge of a MB, we need the next MB row
102 * Within the row, the put pixels loop is also one MB col behind the
103 * decoding loop. The reason for this is again, because for filtering
104 * of the right MB edge, we need the next MB present. */
105 if (!s->first_slice_line) {
107 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
108 if (v->fcm == ILACE_FRAME)
109 fieldtx = v->fieldtx_plane[topleft_mb_pos];
110 stride_y = s->linesize << fieldtx;
111 v_dist = (16 - fieldtx) >> (fieldtx == 0);
112 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
113 s->dest[0] - 16 * s->linesize - 16,
115 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
116 s->dest[0] - 16 * s->linesize - 8,
118 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
119 s->dest[0] - v_dist * s->linesize - 16,
121 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
122 s->dest[0] - v_dist * s->linesize - 8,
124 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
125 s->dest[1] - 8 * s->uvlinesize - 8,
127 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
128 s->dest[2] - 8 * s->uvlinesize - 8,
131 if (s->mb_x == s->mb_width - 1) {
132 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
133 if (v->fcm == ILACE_FRAME)
134 fieldtx = v->fieldtx_plane[top_mb_pos];
135 stride_y = s->linesize << fieldtx;
136 v_dist = fieldtx ? 15 : 8;
137 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
138 s->dest[0] - 16 * s->linesize,
140 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
141 s->dest[0] - 16 * s->linesize + 8,
143 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
144 s->dest[0] - v_dist * s->linesize,
146 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
147 s->dest[0] - v_dist * s->linesize + 8,
149 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
150 s->dest[1] - 8 * s->uvlinesize,
152 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
153 s->dest[2] - 8 * s->uvlinesize,
158 #define inc_blk_idx(idx) do { \
160 if (idx >= v->n_allocated_blks) \
164 inc_blk_idx(v->topleft_blk_idx);
165 inc_blk_idx(v->top_blk_idx);
166 inc_blk_idx(v->left_blk_idx);
167 inc_blk_idx(v->cur_blk_idx);
170 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
172 MpegEncContext *s = &v->s;
174 if (!s->first_slice_line) {
175 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
177 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
178 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
179 for (j = 0; j < 2; j++) {
180 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
182 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
185 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
187 if (s->mb_y == s->end_mb_y - 1) {
189 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
190 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
191 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
193 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
197 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
199 MpegEncContext *s = &v->s;
202 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
203 * means it runs two rows/cols behind the decoding loop. */
204 if (!s->first_slice_line) {
206 if (s->mb_y >= s->start_mb_y + 2) {
207 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
210 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
211 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
212 for (j = 0; j < 2; j++) {
213 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
215 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
219 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
222 if (s->mb_x == s->mb_width - 1) {
223 if (s->mb_y >= s->start_mb_y + 2) {
224 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
227 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
228 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
229 for (j = 0; j < 2; j++) {
230 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
232 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
236 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
239 if (s->mb_y == s->end_mb_y) {
242 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
243 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
245 for (j = 0; j < 2; j++) {
246 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
251 if (s->mb_x == s->mb_width - 1) {
253 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
254 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
256 for (j = 0; j < 2; j++) {
257 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
265 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
267 MpegEncContext *s = &v->s;
270 if (v->condover == CONDOVER_NONE)
273 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
275 /* Within a MB, the horizontal overlap always runs before the vertical.
276 * To accomplish that, we run the H on left and internal borders of the
277 * currently decoded MB. Then, we wait for the next overlap iteration
278 * to do H overlap on the right edge of this MB, before moving over and
279 * running the V overlap. Therefore, the V overlap makes us trail by one
280 * MB col and the H overlap filter makes us trail by one MB row. This
281 * is reflected in the time at which we run the put_pixels loop. */
282 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
283 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
284 v->over_flags_plane[mb_pos - 1])) {
285 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
286 v->block[v->cur_blk_idx][0]);
287 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
288 v->block[v->cur_blk_idx][2]);
289 if (!(s->flags & CODEC_FLAG_GRAY)) {
290 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
291 v->block[v->cur_blk_idx][4]);
292 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
293 v->block[v->cur_blk_idx][5]);
296 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
297 v->block[v->cur_blk_idx][1]);
298 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
299 v->block[v->cur_blk_idx][3]);
301 if (s->mb_x == s->mb_width - 1) {
302 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
303 v->over_flags_plane[mb_pos - s->mb_stride])) {
304 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
305 v->block[v->cur_blk_idx][0]);
306 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
307 v->block[v->cur_blk_idx][1]);
308 if (!(s->flags & CODEC_FLAG_GRAY)) {
309 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
310 v->block[v->cur_blk_idx][4]);
311 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
312 v->block[v->cur_blk_idx][5]);
315 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
316 v->block[v->cur_blk_idx][2]);
317 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
318 v->block[v->cur_blk_idx][3]);
321 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
322 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
323 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
324 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
325 v->block[v->left_blk_idx][0]);
326 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
327 v->block[v->left_blk_idx][1]);
328 if (!(s->flags & CODEC_FLAG_GRAY)) {
329 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
330 v->block[v->left_blk_idx][4]);
331 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
332 v->block[v->left_blk_idx][5]);
335 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
336 v->block[v->left_blk_idx][2]);
337 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
338 v->block[v->left_blk_idx][3]);
342 /** Do motion compensation over 1 macroblock
343 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
345 static void vc1_mc_1mv(VC1Context *v, int dir)
347 MpegEncContext *s = &v->s;
348 DSPContext *dsp = &v->s.dsp;
349 H264ChromaContext *h264chroma = &v->h264chroma;
350 uint8_t *srcY, *srcU, *srcV;
351 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
353 int v_edge_pos = s->v_edge_pos >> v->field_mode;
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 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
366 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
369 uvmx = (mx + ((mx & 3) == 3)) >> 1;
370 uvmy = (my + ((my & 3) == 3)) >> 1;
371 v->luma_mv[s->mb_x][0] = uvmx;
372 v->luma_mv[s->mb_x][1] = uvmy;
375 v->cur_field_type != v->ref_field_type[dir]) {
376 my = my - 2 + 4 * v->cur_field_type;
377 uvmy = uvmy - 2 + 4 * v->cur_field_type;
380 // fastuvmc shall be ignored for interlaced frame picture
381 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
382 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
383 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
385 if (v->field_mode) { // interlaced field picture
387 if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
388 srcY = s->current_picture.f.data[0];
389 srcU = s->current_picture.f.data[1];
390 srcV = s->current_picture.f.data[2];
392 srcY = s->last_picture.f.data[0];
393 srcU = s->last_picture.f.data[1];
394 srcV = s->last_picture.f.data[2];
397 srcY = s->next_picture.f.data[0];
398 srcU = s->next_picture.f.data[1];
399 srcV = s->next_picture.f.data[2];
403 srcY = s->last_picture.f.data[0];
404 srcU = s->last_picture.f.data[1];
405 srcV = s->last_picture.f.data[2];
407 srcY = s->next_picture.f.data[0];
408 srcU = s->next_picture.f.data[1];
409 srcV = s->next_picture.f.data[2];
416 src_x = s->mb_x * 16 + (mx >> 2);
417 src_y = s->mb_y * 16 + (my >> 2);
418 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
419 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
421 if (v->profile != PROFILE_ADVANCED) {
422 src_x = av_clip( src_x, -16, s->mb_width * 16);
423 src_y = av_clip( src_y, -16, s->mb_height * 16);
424 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
425 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
427 src_x = av_clip( src_x, -17, s->avctx->coded_width);
428 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
429 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
430 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
433 srcY += src_y * s->linesize + src_x;
434 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
435 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
437 if (v->field_mode && v->ref_field_type[dir]) {
438 srcY += s->current_picture_ptr->f.linesize[0];
439 srcU += s->current_picture_ptr->f.linesize[1];
440 srcV += s->current_picture_ptr->f.linesize[2];
443 /* for grayscale we should not try to read from unknown area */
444 if (s->flags & CODEC_FLAG_GRAY) {
445 srcU = s->edge_emu_buffer + 18 * s->linesize;
446 srcV = s->edge_emu_buffer + 18 * s->linesize;
449 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
450 || s->h_edge_pos < 22 || v_edge_pos < 22
451 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
452 || (unsigned)(src_y - 1) > v_edge_pos - (my&3) - 16 - 3) {
453 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
455 srcY -= s->mspel * (1 + s->linesize);
456 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
457 17 + s->mspel * 2, 17 + s->mspel * 2,
458 src_x - s->mspel, src_y - s->mspel,
459 s->h_edge_pos, v_edge_pos);
460 srcY = s->edge_emu_buffer;
461 s->vdsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
462 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
463 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
464 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
467 /* if we deal with range reduction we need to scale source blocks */
468 if (v->rangeredfrm) {
473 for (j = 0; j < 17 + s->mspel * 2; j++) {
474 for (i = 0; i < 17 + s->mspel * 2; i++)
475 src[i] = ((src[i] - 128) >> 1) + 128;
480 for (j = 0; j < 9; j++) {
481 for (i = 0; i < 9; i++) {
482 src[i] = ((src[i] - 128) >> 1) + 128;
483 src2[i] = ((src2[i] - 128) >> 1) + 128;
485 src += s->uvlinesize;
486 src2 += s->uvlinesize;
489 /* if we deal with intensity compensation we need to scale source blocks */
490 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
495 for (j = 0; j < 17 + s->mspel * 2; j++) {
496 for (i = 0; i < 17 + s->mspel * 2; i++)
497 src[i] = v->luty[src[i]];
502 for (j = 0; j < 9; j++) {
503 for (i = 0; i < 9; i++) {
504 src[i] = v->lutuv[src[i]];
505 src2[i] = v->lutuv[src2[i]];
507 src += s->uvlinesize;
508 src2 += s->uvlinesize;
511 srcY += s->mspel * (1 + s->linesize);
517 dxy = ((my & 3) << 2) | (mx & 3);
518 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
519 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
520 srcY += s->linesize * 8;
521 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
522 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
523 } else { // hpel mc - always used for luma
524 dxy = (my & 2) | ((mx & 2) >> 1);
526 dsp->put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
528 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
531 if (s->flags & CODEC_FLAG_GRAY) return;
532 /* Chroma MC always uses qpel bilinear */
533 uvmx = (uvmx & 3) << 1;
534 uvmy = (uvmy & 3) << 1;
536 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
537 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
539 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
540 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
544 static inline int median4(int a, int b, int c, int d)
547 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
548 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
550 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
551 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
555 /** Do motion compensation for 4-MV macroblock - luminance block
557 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
559 MpegEncContext *s = &v->s;
560 DSPContext *dsp = &v->s.dsp;
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;
567 if ((!v->field_mode ||
568 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
569 !v->s.last_picture.f.data[0])
572 mx = s->mv[dir][n][0];
573 my = s->mv[dir][n][1];
577 if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field)
578 srcY = s->current_picture.f.data[0];
580 srcY = s->last_picture.f.data[0];
582 srcY = s->last_picture.f.data[0];
584 srcY = s->next_picture.f.data[0];
590 if (v->cur_field_type != v->ref_field_type[dir])
591 my = my - 2 + 4 * v->cur_field_type;
594 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
595 int same_count = 0, opp_count = 0, k;
596 int chosen_mv[2][4][2], f;
598 for (k = 0; k < 4; k++) {
599 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
600 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
601 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
605 f = opp_count > same_count;
606 switch (f ? opp_count : same_count) {
608 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
609 chosen_mv[f][2][0], chosen_mv[f][3][0]);
610 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
611 chosen_mv[f][2][1], chosen_mv[f][3][1]);
614 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
615 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
618 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
619 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
624 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
625 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
626 for (k = 0; k < 4; k++)
627 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
630 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
632 int width = s->avctx->coded_width;
633 int height = s->avctx->coded_height >> 1;
634 qx = (s->mb_x * 16) + (mx >> 2);
635 qy = (s->mb_y * 8) + (my >> 3);
640 mx -= 4 * (qx - width);
643 else if (qy > height + 1)
644 my -= 8 * (qy - height - 1);
647 if ((v->fcm == ILACE_FRAME) && fieldmv)
648 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
650 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
652 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
654 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
656 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
658 if (v->profile != PROFILE_ADVANCED) {
659 src_x = av_clip(src_x, -16, s->mb_width * 16);
660 src_y = av_clip(src_y, -16, s->mb_height * 16);
662 src_x = av_clip(src_x, -17, s->avctx->coded_width);
663 if (v->fcm == ILACE_FRAME) {
665 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
667 src_y = av_clip(src_y, -18, s->avctx->coded_height);
669 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
673 srcY += src_y * s->linesize + src_x;
674 if (v->field_mode && v->ref_field_type[dir])
675 srcY += s->current_picture_ptr->f.linesize[0];
677 if (fieldmv && !(src_y & 1))
679 if (fieldmv && (src_y & 1) && src_y < 4)
681 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
682 || s->h_edge_pos < 13 || v_edge_pos < 23
683 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
684 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
685 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
686 /* check emulate edge stride and offset */
687 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
688 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
689 src_x - s->mspel, src_y - (s->mspel << fieldmv),
690 s->h_edge_pos, v_edge_pos);
691 srcY = s->edge_emu_buffer;
692 /* if we deal with range reduction we need to scale source blocks */
693 if (v->rangeredfrm) {
698 for (j = 0; j < 9 + s->mspel * 2; j++) {
699 for (i = 0; i < 9 + s->mspel * 2; i++)
700 src[i] = ((src[i] - 128) >> 1) + 128;
701 src += s->linesize << fieldmv;
704 /* if we deal with intensity compensation we need to scale source blocks */
705 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
710 for (j = 0; j < 9 + s->mspel * 2; j++) {
711 for (i = 0; i < 9 + s->mspel * 2; i++)
712 src[i] = v->luty[src[i]];
713 src += s->linesize << fieldmv;
716 srcY += s->mspel * (1 + (s->linesize << fieldmv));
720 dxy = ((my & 3) << 2) | (mx & 3);
721 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
722 } else { // hpel mc - always used for luma
723 dxy = (my & 2) | ((mx & 2) >> 1);
725 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
727 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
731 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
734 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
736 idx = ((a[3] != flag) << 3)
737 | ((a[2] != flag) << 2)
738 | ((a[1] != flag) << 1)
741 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
742 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
744 } else if (count[idx] == 1) {
747 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
748 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
751 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
752 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
755 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
756 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
759 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
760 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
763 } else if (count[idx] == 2) {
765 for (i = 0; i < 3; i++)
770 for (i = t1 + 1; i < 4; i++)
775 *tx = (mvx[t1] + mvx[t2]) / 2;
776 *ty = (mvy[t1] + mvy[t2]) / 2;
784 /** Do motion compensation for 4-MV macroblock - both chroma blocks
786 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
788 MpegEncContext *s = &v->s;
789 H264ChromaContext *h264chroma = &v->h264chroma;
790 uint8_t *srcU, *srcV;
791 int uvmx, uvmy, uvsrc_x, uvsrc_y;
792 int k, tx = 0, ty = 0;
793 int mvx[4], mvy[4], intra[4], mv_f[4];
795 int chroma_ref_type = v->cur_field_type, off = 0;
796 int v_edge_pos = s->v_edge_pos >> v->field_mode;
798 if (!v->field_mode && !v->s.last_picture.f.data[0])
800 if (s->flags & CODEC_FLAG_GRAY)
803 for (k = 0; k < 4; k++) {
804 mvx[k] = s->mv[dir][k][0];
805 mvy[k] = s->mv[dir][k][1];
806 intra[k] = v->mb_type[0][s->block_index[k]];
808 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
811 /* calculate chroma MV vector from four luma MVs */
812 if (!v->field_mode || (v->field_mode && !v->numref)) {
813 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
814 chroma_ref_type = v->reffield;
816 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
817 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
818 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
819 return; //no need to do MC for intra blocks
823 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
825 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
827 chroma_ref_type = !v->cur_field_type;
829 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
831 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
832 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
833 uvmx = (tx + ((tx & 3) == 3)) >> 1;
834 uvmy = (ty + ((ty & 3) == 3)) >> 1;
836 v->luma_mv[s->mb_x][0] = uvmx;
837 v->luma_mv[s->mb_x][1] = uvmy;
840 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
841 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
843 // Field conversion bias
844 if (v->cur_field_type != chroma_ref_type)
845 uvmy += 2 - 4 * chroma_ref_type;
847 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
848 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
850 if (v->profile != PROFILE_ADVANCED) {
851 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
852 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
854 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
855 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
860 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
861 srcU = s->current_picture.f.data[1];
862 srcV = s->current_picture.f.data[2];
864 srcU = s->last_picture.f.data[1];
865 srcV = s->last_picture.f.data[2];
868 srcU = s->last_picture.f.data[1];
869 srcV = s->last_picture.f.data[2];
872 srcU = s->next_picture.f.data[1];
873 srcV = s->next_picture.f.data[2];
879 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
880 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
883 if (chroma_ref_type) {
884 srcU += s->current_picture_ptr->f.linesize[1];
885 srcV += s->current_picture_ptr->f.linesize[2];
890 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
891 || s->h_edge_pos < 18 || v_edge_pos < 18
892 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
893 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
894 s->vdsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
895 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
896 s->h_edge_pos >> 1, v_edge_pos >> 1);
897 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
898 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
899 s->h_edge_pos >> 1, v_edge_pos >> 1);
900 srcU = s->edge_emu_buffer;
901 srcV = s->edge_emu_buffer + 16;
903 /* if we deal with range reduction we need to scale source blocks */
904 if (v->rangeredfrm) {
910 for (j = 0; j < 9; j++) {
911 for (i = 0; i < 9; i++) {
912 src[i] = ((src[i] - 128) >> 1) + 128;
913 src2[i] = ((src2[i] - 128) >> 1) + 128;
915 src += s->uvlinesize;
916 src2 += s->uvlinesize;
919 /* if we deal with intensity compensation we need to scale source blocks */
920 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
926 for (j = 0; j < 9; j++) {
927 for (i = 0; i < 9; i++) {
928 src[i] = v->lutuv[src[i]];
929 src2[i] = v->lutuv[src2[i]];
931 src += s->uvlinesize;
932 src2 += s->uvlinesize;
937 /* Chroma MC always uses qpel bilinear */
938 uvmx = (uvmx & 3) << 1;
939 uvmy = (uvmy & 3) << 1;
941 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
942 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
944 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
945 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
949 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
951 static void vc1_mc_4mv_chroma4(VC1Context *v)
953 MpegEncContext *s = &v->s;
954 H264ChromaContext *h264chroma = &v->h264chroma;
955 uint8_t *srcU, *srcV;
956 int uvsrc_x, uvsrc_y;
957 int uvmx_field[4], uvmy_field[4];
959 int fieldmv = v->blk_mv_type[s->block_index[0]];
960 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
961 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
962 int v_edge_pos = s->v_edge_pos >> 1;
964 if (!v->s.last_picture.f.data[0])
966 if (s->flags & CODEC_FLAG_GRAY)
969 for (i = 0; i < 4; i++) {
971 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
974 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
976 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
979 for (i = 0; i < 4; i++) {
980 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
981 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
982 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
983 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
984 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
985 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
986 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
987 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
988 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
989 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
991 if (fieldmv && !(uvsrc_y & 1))
992 v_edge_pos = (s->v_edge_pos >> 1) - 1;
994 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
996 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
997 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
998 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
999 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
1000 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
1001 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1002 s->h_edge_pos >> 1, v_edge_pos);
1003 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
1004 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1005 s->h_edge_pos >> 1, v_edge_pos);
1006 srcU = s->edge_emu_buffer;
1007 srcV = s->edge_emu_buffer + 16;
1009 /* if we deal with intensity compensation we need to scale source blocks */
1010 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1012 uint8_t *src, *src2;
1016 for (j = 0; j < 5; j++) {
1017 for (i = 0; i < 5; i++) {
1018 src[i] = v->lutuv[src[i]];
1019 src2[i] = v->lutuv[src2[i]];
1021 src += s->uvlinesize << 1;
1022 src2 += s->uvlinesize << 1;
1027 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1028 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1030 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]);
1031 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]);
1036 /***********************************************************************/
1038 * @name VC-1 Block-level functions
1039 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1045 * @brief Get macroblock-level quantizer scale
1047 #define GET_MQUANT() \
1048 if (v->dquantfrm) { \
1050 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1051 if (v->dqbilevel) { \
1052 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1054 mqdiff = get_bits(gb, 3); \
1056 mquant = v->pq + mqdiff; \
1058 mquant = get_bits(gb, 5); \
1061 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1062 edges = 1 << v->dqsbedge; \
1063 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1064 edges = (3 << v->dqsbedge) % 15; \
1065 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1067 if ((edges&1) && !s->mb_x) \
1068 mquant = v->altpq; \
1069 if ((edges&2) && s->first_slice_line) \
1070 mquant = v->altpq; \
1071 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1072 mquant = v->altpq; \
1073 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1074 mquant = v->altpq; \
1075 if (!mquant || mquant > 31) { \
1076 av_log(v->s.avctx, AV_LOG_ERROR, \
1077 "Overriding invalid mquant %d\n", mquant); \
1083 * @def GET_MVDATA(_dmv_x, _dmv_y)
1084 * @brief Get MV differentials
1085 * @see MVDATA decoding from 8.3.5.2, p(1)20
1086 * @param _dmv_x Horizontal differential for decoded MV
1087 * @param _dmv_y Vertical differential for decoded MV
1089 #define GET_MVDATA(_dmv_x, _dmv_y) \
1090 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1091 VC1_MV_DIFF_VLC_BITS, 2); \
1093 mb_has_coeffs = 1; \
1096 mb_has_coeffs = 0; \
1099 _dmv_x = _dmv_y = 0; \
1100 } else if (index == 35) { \
1101 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1102 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1103 } else if (index == 36) { \
1108 index1 = index % 6; \
1109 if (!s->quarter_sample && index1 == 5) val = 1; \
1111 if (size_table[index1] - val > 0) \
1112 val = get_bits(gb, size_table[index1] - val); \
1114 sign = 0 - (val&1); \
1115 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1117 index1 = index / 6; \
1118 if (!s->quarter_sample && index1 == 5) val = 1; \
1120 if (size_table[index1] - val > 0) \
1121 val = get_bits(gb, size_table[index1] - val); \
1123 sign = 0 - (val & 1); \
1124 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1127 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1128 int *dmv_y, int *pred_flag)
1131 int extend_x = 0, extend_y = 0;
1132 GetBitContext *gb = &v->s.gb;
1135 const int* offs_tab;
1138 bits = VC1_2REF_MVDATA_VLC_BITS;
1141 bits = VC1_1REF_MVDATA_VLC_BITS;
1144 switch (v->dmvrange) {
1152 extend_x = extend_y = 1;
1155 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1157 *dmv_x = get_bits(gb, v->k_x);
1158 *dmv_y = get_bits(gb, v->k_y);
1161 *pred_flag = *dmv_y & 1;
1162 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1164 *dmv_y = (*dmv_y + (*dmv_y & 1)) >> 1;
1169 av_assert0(index < esc);
1171 offs_tab = offset_table2;
1173 offs_tab = offset_table1;
1174 index1 = (index + 1) % 9;
1176 val = get_bits(gb, index1 + extend_x);
1177 sign = 0 -(val & 1);
1178 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1182 offs_tab = offset_table2;
1184 offs_tab = offset_table1;
1185 index1 = (index + 1) / 9;
1186 if (index1 > v->numref) {
1187 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1188 sign = 0 - (val & 1);
1189 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1192 if (v->numref && pred_flag)
1193 *pred_flag = index1 & 1;
1197 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1199 int scaledvalue, refdist;
1200 int scalesame1, scalesame2;
1201 int scalezone1_x, zone1offset_x;
1202 int table_index = dir ^ v->second_field;
1204 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1205 refdist = v->refdist;
1207 refdist = dir ? v->brfd : v->frfd;
1210 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1211 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1212 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1213 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1218 if (FFABS(n) < scalezone1_x)
1219 scaledvalue = (n * scalesame1) >> 8;
1222 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1224 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1227 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1230 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1232 int scaledvalue, refdist;
1233 int scalesame1, scalesame2;
1234 int scalezone1_y, zone1offset_y;
1235 int table_index = dir ^ v->second_field;
1237 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1238 refdist = v->refdist;
1240 refdist = dir ? v->brfd : v->frfd;
1243 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1244 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1245 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1246 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1251 if (FFABS(n) < scalezone1_y)
1252 scaledvalue = (n * scalesame1) >> 8;
1255 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1257 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1261 if (v->cur_field_type && !v->ref_field_type[dir])
1262 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1264 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1267 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1269 int scalezone1_x, zone1offset_x;
1270 int scaleopp1, scaleopp2, brfd;
1273 brfd = FFMIN(v->brfd, 3);
1274 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1275 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1276 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1277 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1282 if (FFABS(n) < scalezone1_x)
1283 scaledvalue = (n * scaleopp1) >> 8;
1286 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1288 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1291 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1294 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1296 int scalezone1_y, zone1offset_y;
1297 int scaleopp1, scaleopp2, brfd;
1300 brfd = FFMIN(v->brfd, 3);
1301 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1302 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1303 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1304 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1309 if (FFABS(n) < scalezone1_y)
1310 scaledvalue = (n * scaleopp1) >> 8;
1313 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1315 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1318 if (v->cur_field_type && !v->ref_field_type[dir]) {
1319 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1321 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1325 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1328 int brfd, scalesame;
1329 int hpel = 1 - v->s.quarter_sample;
1332 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1334 n = scaleforsame_y(v, i, n, dir) << hpel;
1336 n = scaleforsame_x(v, n, dir) << hpel;
1339 brfd = FFMIN(v->brfd, 3);
1340 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1342 n = (n * scalesame >> 8) << hpel;
1346 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1349 int refdist, scaleopp;
1350 int hpel = 1 - v->s.quarter_sample;
1353 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1355 n = scaleforopp_y(v, n, dir) << hpel;
1357 n = scaleforopp_x(v, n) << hpel;
1360 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1361 refdist = FFMIN(v->refdist, 3);
1363 refdist = dir ? v->brfd : v->frfd;
1364 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1366 n = (n * scaleopp >> 8) << hpel;
1370 /** Predict and set motion vector
1372 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1373 int mv1, int r_x, int r_y, uint8_t* is_intra,
1374 int pred_flag, int dir)
1376 MpegEncContext *s = &v->s;
1377 int xy, wrap, off = 0;
1381 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1382 int opposite, a_f, b_f, c_f;
1383 int16_t field_predA[2];
1384 int16_t field_predB[2];
1385 int16_t field_predC[2];
1386 int a_valid, b_valid, c_valid;
1387 int hybridmv_thresh, y_bias = 0;
1389 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1390 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1394 /* scale MV difference to be quad-pel */
1395 dmv_x <<= 1 - s->quarter_sample;
1396 dmv_y <<= 1 - s->quarter_sample;
1398 wrap = s->b8_stride;
1399 xy = s->block_index[n];
1402 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
1403 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
1404 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
1405 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
1406 if (mv1) { /* duplicate motion data for 1-MV block */
1407 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1408 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1409 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1410 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1411 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1412 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1413 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1414 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1415 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1416 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1417 s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1418 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1419 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1424 C = s->current_picture.f.motion_val[dir][xy - 1 + v->blocks_off];
1425 A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
1427 if (v->field_mode && mixedmv_pic)
1428 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1430 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1432 //in 4-MV mode different blocks have different B predictor position
1435 off = (s->mb_x > 0) ? -1 : 1;
1438 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1447 B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
1449 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1450 b_valid = a_valid && (s->mb_width > 1);
1451 c_valid = s->mb_x || (n == 1 || n == 3);
1452 if (v->field_mode) {
1453 a_valid = a_valid && !is_intra[xy - wrap];
1454 b_valid = b_valid && !is_intra[xy - wrap + off];
1455 c_valid = c_valid && !is_intra[xy - 1];
1459 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1460 num_oppfield += a_f;
1461 num_samefield += 1 - a_f;
1462 field_predA[0] = A[0];
1463 field_predA[1] = A[1];
1465 field_predA[0] = field_predA[1] = 0;
1469 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1470 num_oppfield += b_f;
1471 num_samefield += 1 - b_f;
1472 field_predB[0] = B[0];
1473 field_predB[1] = B[1];
1475 field_predB[0] = field_predB[1] = 0;
1479 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1480 num_oppfield += c_f;
1481 num_samefield += 1 - c_f;
1482 field_predC[0] = C[0];
1483 field_predC[1] = C[1];
1485 field_predC[0] = field_predC[1] = 0;
1489 if (v->field_mode) {
1491 // REFFIELD determines if the last field or the second-last field is
1492 // to be used as reference
1493 opposite = 1 - v->reffield;
1495 if (num_samefield <= num_oppfield)
1496 opposite = 1 - pred_flag;
1498 opposite = pred_flag;
1503 if (a_valid && !a_f) {
1504 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1505 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1507 if (b_valid && !b_f) {
1508 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1509 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1511 if (c_valid && !c_f) {
1512 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1513 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1515 v->mv_f[dir][xy + v->blocks_off] = 1;
1516 v->ref_field_type[dir] = !v->cur_field_type;
1518 if (a_valid && a_f) {
1519 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1520 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1522 if (b_valid && b_f) {
1523 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1524 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1526 if (c_valid && c_f) {
1527 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1528 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1530 v->mv_f[dir][xy + v->blocks_off] = 0;
1531 v->ref_field_type[dir] = v->cur_field_type;
1535 px = field_predA[0];
1536 py = field_predA[1];
1537 } else if (c_valid) {
1538 px = field_predC[0];
1539 py = field_predC[1];
1540 } else if (b_valid) {
1541 px = field_predB[0];
1542 py = field_predB[1];
1548 if (num_samefield + num_oppfield > 1) {
1549 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1550 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1553 /* Pullback MV as specified in 8.3.5.3.4 */
1554 if (!v->field_mode) {
1556 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1557 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1558 X = (s->mb_width << 6) - 4;
1559 Y = (s->mb_height << 6) - 4;
1561 if (qx + px < -60) px = -60 - qx;
1562 if (qy + py < -60) py = -60 - qy;
1564 if (qx + px < -28) px = -28 - qx;
1565 if (qy + py < -28) py = -28 - qy;
1567 if (qx + px > X) px = X - qx;
1568 if (qy + py > Y) py = Y - qy;
1571 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1572 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1573 hybridmv_thresh = 32;
1574 if (a_valid && c_valid) {
1575 if (is_intra[xy - wrap])
1576 sum = FFABS(px) + FFABS(py);
1578 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1579 if (sum > hybridmv_thresh) {
1580 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1581 px = field_predA[0];
1582 py = field_predA[1];
1584 px = field_predC[0];
1585 py = field_predC[1];
1588 if (is_intra[xy - 1])
1589 sum = FFABS(px) + FFABS(py);
1591 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1592 if (sum > hybridmv_thresh) {
1593 if (get_bits1(&s->gb)) {
1594 px = field_predA[0];
1595 py = field_predA[1];
1597 px = field_predC[0];
1598 py = field_predC[1];
1605 if (v->field_mode && v->numref)
1607 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1609 /* store MV using signed modulus of MV range defined in 4.11 */
1610 s->mv[dir][n][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1611 s->mv[dir][n][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
1612 if (mv1) { /* duplicate motion data for 1-MV block */
1613 s->current_picture.f.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1614 s->current_picture.f.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1615 s->current_picture.f.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1616 s->current_picture.f.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1617 s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1618 s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1619 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1620 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];
1624 /** Predict and set motion vector for interlaced frame picture MBs
1626 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1627 int mvn, int r_x, int r_y, uint8_t* is_intra)
1629 MpegEncContext *s = &v->s;
1630 int xy, wrap, off = 0;
1631 int A[2], B[2], C[2];
1633 int a_valid = 0, b_valid = 0, c_valid = 0;
1634 int field_a, field_b, field_c; // 0: same, 1: opposit
1635 int total_valid, num_samefield, num_oppfield;
1636 int pos_c, pos_b, n_adj;
1638 wrap = s->b8_stride;
1639 xy = s->block_index[n];
1642 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
1643 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
1644 s->current_picture.f.motion_val[1][xy][0] = 0;
1645 s->current_picture.f.motion_val[1][xy][1] = 0;
1646 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1647 s->current_picture.f.motion_val[0][xy + 1][0] = 0;
1648 s->current_picture.f.motion_val[0][xy + 1][1] = 0;
1649 s->current_picture.f.motion_val[0][xy + wrap][0] = 0;
1650 s->current_picture.f.motion_val[0][xy + wrap][1] = 0;
1651 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
1652 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
1653 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1654 s->current_picture.f.motion_val[1][xy + 1][0] = 0;
1655 s->current_picture.f.motion_val[1][xy + 1][1] = 0;
1656 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1657 s->current_picture.f.motion_val[1][xy + wrap][1] = 0;
1658 s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
1659 s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
1664 off = ((n == 0) || (n == 1)) ? 1 : -1;
1666 if (s->mb_x || (n == 1) || (n == 3)) {
1667 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1668 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1669 A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
1670 A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
1672 } else { // current block has frame mv and cand. has field MV (so average)
1673 A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
1674 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1675 A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
1676 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1679 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1685 /* Predict B and C */
1686 B[0] = B[1] = C[0] = C[1] = 0;
1687 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1688 if (!s->first_slice_line) {
1689 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1692 pos_b = s->block_index[n_adj] - 2 * wrap;
1693 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1694 n_adj = (n & 2) | (n & 1);
1696 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1697 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1698 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1699 B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1700 B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1703 if (s->mb_width > 1) {
1704 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1707 pos_c = s->block_index[2] - 2 * wrap + 2;
1708 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1711 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1712 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1713 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1714 C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1715 C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1717 if (s->mb_x == s->mb_width - 1) {
1718 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1721 pos_c = s->block_index[3] - 2 * wrap - 2;
1722 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1725 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1726 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1727 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1728 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1729 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1738 pos_b = s->block_index[1];
1740 B[0] = s->current_picture.f.motion_val[0][pos_b][0];
1741 B[1] = s->current_picture.f.motion_val[0][pos_b][1];
1742 pos_c = s->block_index[0];
1744 C[0] = s->current_picture.f.motion_val[0][pos_c][0];
1745 C[1] = s->current_picture.f.motion_val[0][pos_c][1];
1748 total_valid = a_valid + b_valid + c_valid;
1749 // check if predictor A is out of bounds
1750 if (!s->mb_x && !(n == 1 || n == 3)) {
1753 // check if predictor B is out of bounds
1754 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1755 B[0] = B[1] = C[0] = C[1] = 0;
1757 if (!v->blk_mv_type[xy]) {
1758 if (s->mb_width == 1) {
1762 if (total_valid >= 2) {
1763 px = mid_pred(A[0], B[0], C[0]);
1764 py = mid_pred(A[1], B[1], C[1]);
1765 } else if (total_valid) {
1766 if (a_valid) { px = A[0]; py = A[1]; }
1767 else if (b_valid) { px = B[0]; py = B[1]; }
1768 else if (c_valid) { px = C[0]; py = C[1]; }
1775 field_a = (A[1] & 4) ? 1 : 0;
1779 field_b = (B[1] & 4) ? 1 : 0;
1783 field_c = (C[1] & 4) ? 1 : 0;
1787 num_oppfield = field_a + field_b + field_c;
1788 num_samefield = total_valid - num_oppfield;
1789 if (total_valid == 3) {
1790 if ((num_samefield == 3) || (num_oppfield == 3)) {
1791 px = mid_pred(A[0], B[0], C[0]);
1792 py = mid_pred(A[1], B[1], C[1]);
1793 } else if (num_samefield >= num_oppfield) {
1794 /* take one MV from same field set depending on priority
1795 the check for B may not be necessary */
1796 px = !field_a ? A[0] : B[0];
1797 py = !field_a ? A[1] : B[1];
1799 px = field_a ? A[0] : B[0];
1800 py = field_a ? A[1] : B[1];
1802 } else if (total_valid == 2) {
1803 if (num_samefield >= num_oppfield) {
1804 if (!field_a && a_valid) {
1807 } else if (!field_b && b_valid) {
1810 } else if (c_valid) {
1815 if (field_a && a_valid) {
1818 } else if (field_b && b_valid) {
1821 } else if (c_valid) {
1826 } else if (total_valid == 1) {
1827 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1828 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1833 /* store MV using signed modulus of MV range defined in 4.11 */
1834 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1835 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1836 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1837 s->current_picture.f.motion_val[0][xy + 1 ][0] = s->current_picture.f.motion_val[0][xy][0];
1838 s->current_picture.f.motion_val[0][xy + 1 ][1] = s->current_picture.f.motion_val[0][xy][1];
1839 s->current_picture.f.motion_val[0][xy + wrap ][0] = s->current_picture.f.motion_val[0][xy][0];
1840 s->current_picture.f.motion_val[0][xy + wrap ][1] = s->current_picture.f.motion_val[0][xy][1];
1841 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1842 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1843 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1844 s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1845 s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1846 s->mv[0][n + 1][0] = s->mv[0][n][0];
1847 s->mv[0][n + 1][1] = s->mv[0][n][1];
1851 /** Motion compensation for direct or interpolated blocks in B-frames
1853 static void vc1_interp_mc(VC1Context *v)
1855 MpegEncContext *s = &v->s;
1856 DSPContext *dsp = &v->s.dsp;
1857 H264ChromaContext *h264chroma = &v->h264chroma;
1858 uint8_t *srcY, *srcU, *srcV;
1859 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1861 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1863 if (!v->field_mode && !v->s.next_picture.f.data[0])
1866 mx = s->mv[1][0][0];
1867 my = s->mv[1][0][1];
1868 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1869 uvmy = (my + ((my & 3) == 3)) >> 1;
1870 if (v->field_mode) {
1871 if (v->cur_field_type != v->ref_field_type[1])
1872 my = my - 2 + 4 * v->cur_field_type;
1873 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1876 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1877 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1879 srcY = s->next_picture.f.data[0];
1880 srcU = s->next_picture.f.data[1];
1881 srcV = s->next_picture.f.data[2];
1883 src_x = s->mb_x * 16 + (mx >> 2);
1884 src_y = s->mb_y * 16 + (my >> 2);
1885 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1886 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1888 if (v->profile != PROFILE_ADVANCED) {
1889 src_x = av_clip( src_x, -16, s->mb_width * 16);
1890 src_y = av_clip( src_y, -16, s->mb_height * 16);
1891 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1892 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1894 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1895 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1896 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1897 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1900 srcY += src_y * s->linesize + src_x;
1901 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1902 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1904 if (v->field_mode && v->ref_field_type[1]) {
1905 srcY += s->current_picture_ptr->f.linesize[0];
1906 srcU += s->current_picture_ptr->f.linesize[1];
1907 srcV += s->current_picture_ptr->f.linesize[2];
1910 /* for grayscale we should not try to read from unknown area */
1911 if (s->flags & CODEC_FLAG_GRAY) {
1912 srcU = s->edge_emu_buffer + 18 * s->linesize;
1913 srcV = s->edge_emu_buffer + 18 * s->linesize;
1916 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1917 || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1918 || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1919 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1921 srcY -= s->mspel * (1 + s->linesize);
1922 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1923 17 + s->mspel * 2, 17 + s->mspel * 2,
1924 src_x - s->mspel, src_y - s->mspel,
1925 s->h_edge_pos, v_edge_pos);
1926 srcY = s->edge_emu_buffer;
1927 s->vdsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1928 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1929 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1930 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1933 /* if we deal with range reduction we need to scale source blocks */
1934 if (v->rangeredfrm) {
1936 uint8_t *src, *src2;
1939 for (j = 0; j < 17 + s->mspel * 2; j++) {
1940 for (i = 0; i < 17 + s->mspel * 2; i++)
1941 src[i] = ((src[i] - 128) >> 1) + 128;
1946 for (j = 0; j < 9; j++) {
1947 for (i = 0; i < 9; i++) {
1948 src[i] = ((src[i] - 128) >> 1) + 128;
1949 src2[i] = ((src2[i] - 128) >> 1) + 128;
1951 src += s->uvlinesize;
1952 src2 += s->uvlinesize;
1955 srcY += s->mspel * (1 + s->linesize);
1962 dxy = ((my & 3) << 2) | (mx & 3);
1963 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
1964 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1965 srcY += s->linesize * 8;
1966 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
1967 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1969 dxy = (my & 2) | ((mx & 2) >> 1);
1972 dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1974 dsp->avg_no_rnd_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, 16);
1977 if (s->flags & CODEC_FLAG_GRAY) return;
1978 /* Chroma MC always uses qpel blilinear */
1979 uvmx = (uvmx & 3) << 1;
1980 uvmy = (uvmy & 3) << 1;
1982 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1983 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1985 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1986 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1990 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1994 #if B_FRACTION_DEN==256
1998 return 2 * ((value * n + 255) >> 9);
1999 return (value * n + 128) >> 8;
2002 n -= B_FRACTION_DEN;
2004 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2005 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2009 /** Reconstruct motion vector for B-frame and do motion compensation
2011 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2012 int direct, int mode)
2015 v->mv_mode2 = v->mv_mode;
2016 v->mv_mode = MV_PMODE_INTENSITY_COMP;
2022 v->mv_mode = v->mv_mode2;
2025 if (mode == BMV_TYPE_INTERPOLATED) {
2029 v->mv_mode = v->mv_mode2;
2033 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2034 v->mv_mode = v->mv_mode2;
2035 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2037 v->mv_mode = v->mv_mode2;
2040 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2041 int direct, int mvtype)
2043 MpegEncContext *s = &v->s;
2044 int xy, wrap, off = 0;
2049 const uint8_t *is_intra = v->mb_type[0];
2053 /* scale MV difference to be quad-pel */
2054 dmv_x[0] <<= 1 - s->quarter_sample;
2055 dmv_y[0] <<= 1 - s->quarter_sample;
2056 dmv_x[1] <<= 1 - s->quarter_sample;
2057 dmv_y[1] <<= 1 - s->quarter_sample;
2059 wrap = s->b8_stride;
2060 xy = s->block_index[0];
2063 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
2064 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
2065 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
2066 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
2069 if (!v->field_mode) {
2070 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2071 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2072 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2073 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2075 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2076 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));
2077 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));
2078 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));
2079 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));
2082 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2083 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2084 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2085 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2089 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2090 C = s->current_picture.f.motion_val[0][xy - 2];
2091 A = s->current_picture.f.motion_val[0][xy - wrap * 2];
2092 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2093 B = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
2095 if (!s->mb_x) C[0] = C[1] = 0;
2096 if (!s->first_slice_line) { // predictor A is not out of bounds
2097 if (s->mb_width == 1) {
2101 px = mid_pred(A[0], B[0], C[0]);
2102 py = mid_pred(A[1], B[1], C[1]);
2104 } else if (s->mb_x) { // predictor C is not out of bounds
2110 /* Pullback MV as specified in 8.3.5.3.4 */
2113 if (v->profile < PROFILE_ADVANCED) {
2114 qx = (s->mb_x << 5);
2115 qy = (s->mb_y << 5);
2116 X = (s->mb_width << 5) - 4;
2117 Y = (s->mb_height << 5) - 4;
2118 if (qx + px < -28) px = -28 - qx;
2119 if (qy + py < -28) py = -28 - qy;
2120 if (qx + px > X) px = X - qx;
2121 if (qy + py > Y) py = Y - qy;
2123 qx = (s->mb_x << 6);
2124 qy = (s->mb_y << 6);
2125 X = (s->mb_width << 6) - 4;
2126 Y = (s->mb_height << 6) - 4;
2127 if (qx + px < -60) px = -60 - qx;
2128 if (qy + py < -60) py = -60 - qy;
2129 if (qx + px > X) px = X - qx;
2130 if (qy + py > Y) py = Y - qy;
2133 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2134 if (0 && !s->first_slice_line && s->mb_x) {
2135 if (is_intra[xy - wrap])
2136 sum = FFABS(px) + FFABS(py);
2138 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2140 if (get_bits1(&s->gb)) {
2148 if (is_intra[xy - 2])
2149 sum = FFABS(px) + FFABS(py);
2151 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2153 if (get_bits1(&s->gb)) {
2163 /* store MV using signed modulus of MV range defined in 4.11 */
2164 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2165 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2167 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2168 C = s->current_picture.f.motion_val[1][xy - 2];
2169 A = s->current_picture.f.motion_val[1][xy - wrap * 2];
2170 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2171 B = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
2175 if (!s->first_slice_line) { // predictor A is not out of bounds
2176 if (s->mb_width == 1) {
2180 px = mid_pred(A[0], B[0], C[0]);
2181 py = mid_pred(A[1], B[1], C[1]);
2183 } else if (s->mb_x) { // predictor C is not out of bounds
2189 /* Pullback MV as specified in 8.3.5.3.4 */
2192 if (v->profile < PROFILE_ADVANCED) {
2193 qx = (s->mb_x << 5);
2194 qy = (s->mb_y << 5);
2195 X = (s->mb_width << 5) - 4;
2196 Y = (s->mb_height << 5) - 4;
2197 if (qx + px < -28) px = -28 - qx;
2198 if (qy + py < -28) py = -28 - qy;
2199 if (qx + px > X) px = X - qx;
2200 if (qy + py > Y) py = Y - qy;
2202 qx = (s->mb_x << 6);
2203 qy = (s->mb_y << 6);
2204 X = (s->mb_width << 6) - 4;
2205 Y = (s->mb_height << 6) - 4;
2206 if (qx + px < -60) px = -60 - qx;
2207 if (qy + py < -60) py = -60 - qy;
2208 if (qx + px > X) px = X - qx;
2209 if (qy + py > Y) py = Y - qy;
2212 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2213 if (0 && !s->first_slice_line && s->mb_x) {
2214 if (is_intra[xy - wrap])
2215 sum = FFABS(px) + FFABS(py);
2217 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2219 if (get_bits1(&s->gb)) {
2227 if (is_intra[xy - 2])
2228 sum = FFABS(px) + FFABS(py);
2230 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2232 if (get_bits1(&s->gb)) {
2242 /* store MV using signed modulus of MV range defined in 4.11 */
2244 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2245 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2247 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
2248 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
2249 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
2250 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
2253 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2255 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2256 MpegEncContext *s = &v->s;
2257 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2259 if (v->bmvtype == BMV_TYPE_DIRECT) {
2260 int total_opp, k, f;
2261 if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2262 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2263 v->bfraction, 0, s->quarter_sample);
2264 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2265 v->bfraction, 0, s->quarter_sample);
2266 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2267 v->bfraction, 1, s->quarter_sample);
2268 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2269 v->bfraction, 1, s->quarter_sample);
2271 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2272 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2273 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2274 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2275 f = (total_opp > 2) ? 1 : 0;
2277 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2278 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2281 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2282 for (k = 0; k < 4; k++) {
2283 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2284 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2285 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2286 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2287 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2288 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2292 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2293 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);
2294 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);
2297 if (dir) { // backward
2298 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);
2299 if (n == 3 || mv1) {
2300 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2303 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);
2304 if (n == 3 || mv1) {
2305 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2310 /** Get predicted DC value for I-frames only
2311 * prediction dir: left=0, top=1
2312 * @param s MpegEncContext
2313 * @param overlap flag indicating that overlap filtering is used
2314 * @param pq integer part of picture quantizer
2315 * @param[in] n block index in the current MB
2316 * @param dc_val_ptr Pointer to DC predictor
2317 * @param dir_ptr Prediction direction for use in AC prediction
2319 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2320 int16_t **dc_val_ptr, int *dir_ptr)
2322 int a, b, c, wrap, pred, scale;
2324 static const uint16_t dcpred[32] = {
2325 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2326 114, 102, 93, 85, 79, 73, 68, 64,
2327 60, 57, 54, 51, 49, 47, 45, 43,
2328 41, 39, 38, 37, 35, 34, 33
2331 /* find prediction - wmv3_dc_scale always used here in fact */
2332 if (n < 4) scale = s->y_dc_scale;
2333 else scale = s->c_dc_scale;
2335 wrap = s->block_wrap[n];
2336 dc_val = s->dc_val[0] + s->block_index[n];
2342 b = dc_val[ - 1 - wrap];
2343 a = dc_val[ - wrap];
2345 if (pq < 9 || !overlap) {
2346 /* Set outer values */
2347 if (s->first_slice_line && (n != 2 && n != 3))
2348 b = a = dcpred[scale];
2349 if (s->mb_x == 0 && (n != 1 && n != 3))
2350 b = c = dcpred[scale];
2352 /* Set outer values */
2353 if (s->first_slice_line && (n != 2 && n != 3))
2355 if (s->mb_x == 0 && (n != 1 && n != 3))
2359 if (abs(a - b) <= abs(b - c)) {
2361 *dir_ptr = 1; // left
2364 *dir_ptr = 0; // top
2367 /* update predictor */
2368 *dc_val_ptr = &dc_val[0];
2373 /** Get predicted DC value
2374 * prediction dir: left=0, top=1
2375 * @param s MpegEncContext
2376 * @param overlap flag indicating that overlap filtering is used
2377 * @param pq integer part of picture quantizer
2378 * @param[in] n block index in the current MB
2379 * @param a_avail flag indicating top block availability
2380 * @param c_avail flag indicating left block availability
2381 * @param dc_val_ptr Pointer to DC predictor
2382 * @param dir_ptr Prediction direction for use in AC prediction
2384 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2385 int a_avail, int c_avail,
2386 int16_t **dc_val_ptr, int *dir_ptr)
2388 int a, b, c, wrap, pred;
2390 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2394 wrap = s->block_wrap[n];
2395 dc_val = s->dc_val[0] + s->block_index[n];
2401 b = dc_val[ - 1 - wrap];
2402 a = dc_val[ - wrap];
2403 /* scale predictors if needed */
2404 q1 = s->current_picture.f.qscale_table[mb_pos];
2405 dqscale_index = s->y_dc_scale_table[q1] - 1;
2406 if (dqscale_index < 0)
2408 if (c_avail && (n != 1 && n != 3)) {
2409 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2411 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2413 if (a_avail && (n != 2 && n != 3)) {
2414 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2416 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2418 if (a_avail && c_avail && (n != 3)) {
2423 off -= s->mb_stride;
2424 q2 = s->current_picture.f.qscale_table[off];
2426 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2429 if (a_avail && c_avail) {
2430 if (abs(a - b) <= abs(b - c)) {
2432 *dir_ptr = 1; // left
2435 *dir_ptr = 0; // top
2437 } else if (a_avail) {
2439 *dir_ptr = 0; // top
2440 } else if (c_avail) {
2442 *dir_ptr = 1; // left
2445 *dir_ptr = 1; // left
2448 /* update predictor */
2449 *dc_val_ptr = &dc_val[0];
2453 /** @} */ // Block group
2456 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2457 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2461 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2462 uint8_t **coded_block_ptr)
2464 int xy, wrap, pred, a, b, c;
2466 xy = s->block_index[n];
2467 wrap = s->b8_stride;
2472 a = s->coded_block[xy - 1 ];
2473 b = s->coded_block[xy - 1 - wrap];
2474 c = s->coded_block[xy - wrap];
2483 *coded_block_ptr = &s->coded_block[xy];
2489 * Decode one AC coefficient
2490 * @param v The VC1 context
2491 * @param last Last coefficient
2492 * @param skip How much zero coefficients to skip
2493 * @param value Decoded AC coefficient value
2494 * @param codingset set of VLC to decode data
2497 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2498 int *value, int codingset)
2500 GetBitContext *gb = &v->s.gb;
2501 int index, escape, run = 0, level = 0, lst = 0;
2503 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2504 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2505 run = vc1_index_decode_table[codingset][index][0];
2506 level = vc1_index_decode_table[codingset][index][1];
2507 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2511 escape = decode210(gb);
2513 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2514 run = vc1_index_decode_table[codingset][index][0];
2515 level = vc1_index_decode_table[codingset][index][1];
2516 lst = index >= vc1_last_decode_table[codingset];
2519 level += vc1_last_delta_level_table[codingset][run];
2521 level += vc1_delta_level_table[codingset][run];
2524 run += vc1_last_delta_run_table[codingset][level] + 1;
2526 run += vc1_delta_run_table[codingset][level] + 1;
2532 lst = get_bits1(gb);
2533 if (v->s.esc3_level_length == 0) {
2534 if (v->pq < 8 || v->dquantfrm) { // table 59
2535 v->s.esc3_level_length = get_bits(gb, 3);
2536 if (!v->s.esc3_level_length)
2537 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2538 } else { // table 60
2539 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2541 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2543 run = get_bits(gb, v->s.esc3_run_length);
2544 sign = get_bits1(gb);
2545 level = get_bits(gb, v->s.esc3_level_length);
2556 /** Decode intra block in intra frames - should be faster than decode_intra_block
2557 * @param v VC1Context
2558 * @param block block to decode
2559 * @param[in] n subblock index
2560 * @param coded are AC coeffs present or not
2561 * @param codingset set of VLC to decode data
2563 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
2564 int coded, int codingset)
2566 GetBitContext *gb = &v->s.gb;
2567 MpegEncContext *s = &v->s;
2568 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2571 int16_t *ac_val, *ac_val2;
2574 /* Get DC differential */
2576 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2578 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2581 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2585 if (dcdiff == 119 /* ESC index value */) {
2586 /* TODO: Optimize */
2587 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2588 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2589 else dcdiff = get_bits(gb, 8);
2592 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2593 else if (v->pq == 2)
2594 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2601 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2604 /* Store the quantized DC coeff, used for prediction */
2606 block[0] = dcdiff * s->y_dc_scale;
2608 block[0] = dcdiff * s->c_dc_scale;
2619 int last = 0, skip, value;
2620 const uint8_t *zz_table;
2624 scale = v->pq * 2 + v->halfpq;
2628 zz_table = v->zz_8x8[2];
2630 zz_table = v->zz_8x8[3];
2632 zz_table = v->zz_8x8[1];
2634 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2636 if (dc_pred_dir) // left
2639 ac_val -= 16 * s->block_wrap[n];
2642 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2646 block[zz_table[i++]] = value;
2649 /* apply AC prediction if needed */
2651 if (dc_pred_dir) { // left
2652 for (k = 1; k < 8; k++)
2653 block[k << v->left_blk_sh] += ac_val[k];
2655 for (k = 1; k < 8; k++)
2656 block[k << v->top_blk_sh] += ac_val[k + 8];
2659 /* save AC coeffs for further prediction */
2660 for (k = 1; k < 8; k++) {
2661 ac_val2[k] = block[k << v->left_blk_sh];
2662 ac_val2[k + 8] = block[k << v->top_blk_sh];
2665 /* scale AC coeffs */
2666 for (k = 1; k < 64; k++)
2670 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2673 if (s->ac_pred) i = 63;
2679 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2683 scale = v->pq * 2 + v->halfpq;
2684 memset(ac_val2, 0, 16 * 2);
2685 if (dc_pred_dir) { // left
2688 memcpy(ac_val2, ac_val, 8 * 2);
2690 ac_val -= 16 * s->block_wrap[n];
2692 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2695 /* apply AC prediction if needed */
2697 if (dc_pred_dir) { //left
2698 for (k = 1; k < 8; k++) {
2699 block[k << v->left_blk_sh] = ac_val[k] * scale;
2700 if (!v->pquantizer && block[k << v->left_blk_sh])
2701 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2704 for (k = 1; k < 8; k++) {
2705 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2706 if (!v->pquantizer && block[k << v->top_blk_sh])
2707 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2713 s->block_last_index[n] = i;
2718 /** Decode intra block in intra frames - should be faster than decode_intra_block
2719 * @param v VC1Context
2720 * @param block block to decode
2721 * @param[in] n subblock number
2722 * @param coded are AC coeffs present or not
2723 * @param codingset set of VLC to decode data
2724 * @param mquant quantizer value for this macroblock
2726 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
2727 int coded, int codingset, int mquant)
2729 GetBitContext *gb = &v->s.gb;
2730 MpegEncContext *s = &v->s;
2731 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2733 int16_t *dc_val = NULL;
2734 int16_t *ac_val, *ac_val2;
2736 int a_avail = v->a_avail, c_avail = v->c_avail;
2737 int use_pred = s->ac_pred;
2740 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2742 /* Get DC differential */
2744 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2746 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2749 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2753 if (dcdiff == 119 /* ESC index value */) {
2754 /* TODO: Optimize */
2755 if (mquant == 1) dcdiff = get_bits(gb, 10);
2756 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2757 else dcdiff = get_bits(gb, 8);
2760 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2761 else if (mquant == 2)
2762 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2769 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2772 /* Store the quantized DC coeff, used for prediction */
2774 block[0] = dcdiff * s->y_dc_scale;
2776 block[0] = dcdiff * s->c_dc_scale;
2782 /* check if AC is needed at all */
2783 if (!a_avail && !c_avail)
2785 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2788 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2790 if (dc_pred_dir) // left
2793 ac_val -= 16 * s->block_wrap[n];
2795 q1 = s->current_picture.f.qscale_table[mb_pos];
2796 if ( dc_pred_dir && c_avail && mb_pos)
2797 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2798 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2799 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2800 if ( dc_pred_dir && n == 1)
2802 if (!dc_pred_dir && n == 2)
2808 int last = 0, skip, value;
2809 const uint8_t *zz_table;
2813 if (!use_pred && v->fcm == ILACE_FRAME) {
2814 zz_table = v->zzi_8x8;
2816 if (!dc_pred_dir) // top
2817 zz_table = v->zz_8x8[2];
2819 zz_table = v->zz_8x8[3];
2822 if (v->fcm != ILACE_FRAME)
2823 zz_table = v->zz_8x8[1];
2825 zz_table = v->zzi_8x8;
2829 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2833 block[zz_table[i++]] = value;
2836 /* apply AC prediction if needed */
2838 /* scale predictors if needed*/
2839 if (q2 && q1 != q2) {
2840 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2841 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2844 return AVERROR_INVALIDDATA;
2845 if (dc_pred_dir) { // left
2846 for (k = 1; k < 8; k++)
2847 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2849 for (k = 1; k < 8; k++)
2850 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2853 if (dc_pred_dir) { //left
2854 for (k = 1; k < 8; k++)
2855 block[k << v->left_blk_sh] += ac_val[k];
2857 for (k = 1; k < 8; k++)
2858 block[k << v->top_blk_sh] += ac_val[k + 8];
2862 /* save AC coeffs for further prediction */
2863 for (k = 1; k < 8; k++) {
2864 ac_val2[k ] = block[k << v->left_blk_sh];
2865 ac_val2[k + 8] = block[k << v->top_blk_sh];
2868 /* scale AC coeffs */
2869 for (k = 1; k < 64; k++)
2873 block[k] += (block[k] < 0) ? -mquant : mquant;
2876 if (use_pred) i = 63;
2877 } else { // no AC coeffs
2880 memset(ac_val2, 0, 16 * 2);
2881 if (dc_pred_dir) { // left
2883 memcpy(ac_val2, ac_val, 8 * 2);
2884 if (q2 && q1 != q2) {
2885 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2886 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2888 return AVERROR_INVALIDDATA;
2889 for (k = 1; k < 8; k++)
2890 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2895 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2896 if (q2 && q1 != q2) {
2897 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2898 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2900 return AVERROR_INVALIDDATA;
2901 for (k = 1; k < 8; k++)
2902 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2907 /* apply AC prediction if needed */
2909 if (dc_pred_dir) { // left
2910 for (k = 1; k < 8; k++) {
2911 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2912 if (!v->pquantizer && block[k << v->left_blk_sh])
2913 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2916 for (k = 1; k < 8; k++) {
2917 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2918 if (!v->pquantizer && block[k << v->top_blk_sh])
2919 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2925 s->block_last_index[n] = i;
2930 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2931 * @param v VC1Context
2932 * @param block block to decode
2933 * @param[in] n subblock index
2934 * @param coded are AC coeffs present or not
2935 * @param mquant block quantizer
2936 * @param codingset set of VLC to decode data
2938 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
2939 int coded, int mquant, int codingset)
2941 GetBitContext *gb = &v->s.gb;
2942 MpegEncContext *s = &v->s;
2943 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2945 int16_t *dc_val = NULL;
2946 int16_t *ac_val, *ac_val2;
2948 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2949 int a_avail = v->a_avail, c_avail = v->c_avail;
2950 int use_pred = s->ac_pred;
2954 s->dsp.clear_block(block);
2956 /* XXX: Guard against dumb values of mquant */
2957 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2959 /* Set DC scale - y and c use the same */
2960 s->y_dc_scale = s->y_dc_scale_table[mquant];
2961 s->c_dc_scale = s->c_dc_scale_table[mquant];
2963 /* Get DC differential */
2965 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2967 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2970 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2974 if (dcdiff == 119 /* ESC index value */) {
2975 /* TODO: Optimize */
2976 if (mquant == 1) dcdiff = get_bits(gb, 10);
2977 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2978 else dcdiff = get_bits(gb, 8);
2981 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2982 else if (mquant == 2)
2983 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2990 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2993 /* Store the quantized DC coeff, used for prediction */
2996 block[0] = dcdiff * s->y_dc_scale;
2998 block[0] = dcdiff * s->c_dc_scale;
3004 /* check if AC is needed at all and adjust direction if needed */
3005 if (!a_avail) dc_pred_dir = 1;
3006 if (!c_avail) dc_pred_dir = 0;
3007 if (!a_avail && !c_avail) use_pred = 0;
3008 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3011 scale = mquant * 2 + v->halfpq;
3013 if (dc_pred_dir) //left
3016 ac_val -= 16 * s->block_wrap[n];
3018 q1 = s->current_picture.f.qscale_table[mb_pos];
3019 if (dc_pred_dir && c_avail && mb_pos)
3020 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
3021 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3022 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
3023 if ( dc_pred_dir && n == 1)
3025 if (!dc_pred_dir && n == 2)
3027 if (n == 3) q2 = q1;
3030 int last = 0, skip, value;
3034 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3038 if (v->fcm == PROGRESSIVE)
3039 block[v->zz_8x8[0][i++]] = value;
3041 if (use_pred && (v->fcm == ILACE_FRAME)) {
3042 if (!dc_pred_dir) // top
3043 block[v->zz_8x8[2][i++]] = value;
3045 block[v->zz_8x8[3][i++]] = value;
3047 block[v->zzi_8x8[i++]] = value;
3052 /* apply AC prediction if needed */
3054 /* scale predictors if needed*/
3055 if (q2 && q1 != q2) {
3056 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3057 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3060 return AVERROR_INVALIDDATA;
3061 if (dc_pred_dir) { // left
3062 for (k = 1; k < 8; k++)
3063 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3065 for (k = 1; k < 8; k++)
3066 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3069 if (dc_pred_dir) { // left
3070 for (k = 1; k < 8; k++)
3071 block[k << v->left_blk_sh] += ac_val[k];
3073 for (k = 1; k < 8; k++)
3074 block[k << v->top_blk_sh] += ac_val[k + 8];
3078 /* save AC coeffs for further prediction */
3079 for (k = 1; k < 8; k++) {
3080 ac_val2[k ] = block[k << v->left_blk_sh];
3081 ac_val2[k + 8] = block[k << v->top_blk_sh];
3084 /* scale AC coeffs */
3085 for (k = 1; k < 64; k++)
3089 block[k] += (block[k] < 0) ? -mquant : mquant;
3092 if (use_pred) i = 63;
3093 } else { // no AC coeffs
3096 memset(ac_val2, 0, 16 * 2);
3097 if (dc_pred_dir) { // left
3099 memcpy(ac_val2, ac_val, 8 * 2);
3100 if (q2 && q1 != q2) {
3101 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3102 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3104 return AVERROR_INVALIDDATA;
3105 for (k = 1; k < 8; k++)
3106 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3111 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3112 if (q2 && q1 != q2) {
3113 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3114 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3116 return AVERROR_INVALIDDATA;
3117 for (k = 1; k < 8; k++)
3118 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3123 /* apply AC prediction if needed */
3125 if (dc_pred_dir) { // left
3126 for (k = 1; k < 8; k++) {
3127 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3128 if (!v->pquantizer && block[k << v->left_blk_sh])
3129 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3132 for (k = 1; k < 8; k++) {
3133 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3134 if (!v->pquantizer && block[k << v->top_blk_sh])
3135 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3141 s->block_last_index[n] = i;
3148 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
3149 int mquant, int ttmb, int first_block,
3150 uint8_t *dst, int linesize, int skip_block,
3153 MpegEncContext *s = &v->s;
3154 GetBitContext *gb = &s->gb;
3157 int scale, off, idx, last, skip, value;
3158 int ttblk = ttmb & 7;
3161 s->dsp.clear_block(block);
3164 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)];
3166 if (ttblk == TT_4X4) {
3167 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3169 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3170 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3171 || (!v->res_rtm_flag && !first_block))) {
3172 subblkpat = decode012(gb);
3174 subblkpat ^= 3; // swap decoded pattern bits
3175 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3177 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3180 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3182 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3183 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3184 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3187 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3188 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3197 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3202 idx = v->zz_8x8[0][i++];
3204 idx = v->zzi_8x8[i++];
3205 block[idx] = value * scale;
3207 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3211 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3213 v->vc1dsp.vc1_inv_trans_8x8(block);
3214 s->dsp.add_pixels_clamped(block, dst, linesize);
3219 pat = ~subblkpat & 0xF;
3220 for (j = 0; j < 4; j++) {
3221 last = subblkpat & (1 << (3 - j));
3223 off = (j & 1) * 4 + (j & 2) * 16;
3225 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3230 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3232 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3233 block[idx + off] = value * scale;
3235 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3237 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3239 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3241 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3246 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3247 for (j = 0; j < 2; j++) {
3248 last = subblkpat & (1 << (1 - j));
3252 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3257 idx = v->zz_8x4[i++] + off;
3259 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3260 block[idx] = value * scale;
3262 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3264 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3266 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3268 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3273 pat = ~(subblkpat * 5) & 0xF;
3274 for (j = 0; j < 2; j++) {
3275 last = subblkpat & (1 << (1 - j));
3279 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3284 idx = v->zz_4x8[i++] + off;
3286 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3287 block[idx] = value * scale;
3289 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3291 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3293 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3295 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3301 *ttmb_out |= ttblk << (n * 4);
3305 /** @} */ // Macroblock group
3307 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3308 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3310 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3312 MpegEncContext *s = &v->s;
3313 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3314 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3315 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3316 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3317 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3320 if (block_num > 3) {
3321 dst = s->dest[block_num - 3];
3323 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3325 if (s->mb_y != s->end_mb_y || block_num < 2) {
3329 if (block_num > 3) {
3330 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3331 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3332 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3333 mv_stride = s->mb_stride;
3335 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3336 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3337 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3338 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3339 mv_stride = s->b8_stride;
3340 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3343 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3344 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3345 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3347 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3349 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3352 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3354 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3359 dst -= 4 * linesize;
3360 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3361 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3362 idx = (block_cbp | (block_cbp >> 2)) & 3;
3364 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3367 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3369 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3374 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3376 MpegEncContext *s = &v->s;
3377 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3378 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3379 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3380 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3381 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3384 if (block_num > 3) {
3385 dst = s->dest[block_num - 3] - 8 * linesize;
3387 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3390 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3393 if (block_num > 3) {
3394 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3395 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3396 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3398 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3399 : (mb_cbp >> ((block_num + 1) * 4));
3400 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3401 : (mb_is_intra >> ((block_num + 1) * 4));
3402 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3404 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3405 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3407 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3409 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3412 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3414 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3420 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3421 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3422 idx = (block_cbp | (block_cbp >> 1)) & 5;
3424 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3427 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3429 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3434 static void vc1_apply_p_loop_filter(VC1Context *v)
3436 MpegEncContext *s = &v->s;
3439 for (i = 0; i < 6; i++) {
3440 vc1_apply_p_v_loop_filter(v, i);
3443 /* V always precedes H, therefore we run H one MB before V;
3444 * at the end of a row, we catch up to complete the row */
3446 for (i = 0; i < 6; i++) {
3447 vc1_apply_p_h_loop_filter(v, i);
3449 if (s->mb_x == s->mb_width - 1) {
3451 ff_update_block_index(s);
3452 for (i = 0; i < 6; i++) {
3453 vc1_apply_p_h_loop_filter(v, i);
3459 /** Decode one P-frame MB
3461 static int vc1_decode_p_mb(VC1Context *v)
3463 MpegEncContext *s = &v->s;
3464 GetBitContext *gb = &s->gb;
3466 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3467 int cbp; /* cbp decoding stuff */
3468 int mqdiff, mquant; /* MB quantization */
3469 int ttmb = v->ttfrm; /* MB Transform type */
3471 int mb_has_coeffs = 1; /* last_flag */
3472 int dmv_x, dmv_y; /* Differential MV components */
3473 int index, index1; /* LUT indexes */
3474 int val, sign; /* temp values */
3475 int first_block = 1;
3477 int skipped, fourmv;
3478 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3480 mquant = v->pq; /* lossy initialization */
3482 if (v->mv_type_is_raw)
3483 fourmv = get_bits1(gb);
3485 fourmv = v->mv_type_mb_plane[mb_pos];
3487 skipped = get_bits1(gb);
3489 skipped = v->s.mbskip_table[mb_pos];
3491 if (!fourmv) { /* 1MV mode */
3493 GET_MVDATA(dmv_x, dmv_y);
3496 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3497 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3499 s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3500 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3502 /* FIXME Set DC val for inter block ? */
3503 if (s->mb_intra && !mb_has_coeffs) {
3505 s->ac_pred = get_bits1(gb);
3507 } else if (mb_has_coeffs) {
3509 s->ac_pred = get_bits1(gb);
3510 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3516 s->current_picture.f.qscale_table[mb_pos] = mquant;
3518 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3519 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3520 VC1_TTMB_VLC_BITS, 2);
3521 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3523 for (i = 0; i < 6; i++) {
3524 s->dc_val[0][s->block_index[i]] = 0;
3526 val = ((cbp >> (5 - i)) & 1);
3527 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3528 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3530 /* check if prediction blocks A and C are available */
3531 v->a_avail = v->c_avail = 0;
3532 if (i == 2 || i == 3 || !s->first_slice_line)
3533 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3534 if (i == 1 || i == 3 || s->mb_x)
3535 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3537 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3538 (i & 4) ? v->codingset2 : v->codingset);
3539 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3541 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3543 for (j = 0; j < 64; j++)
3544 s->block[i][j] <<= 1;
3545 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3546 if (v->pq >= 9 && v->overlap) {
3548 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3550 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3552 block_cbp |= 0xF << (i << 2);
3553 block_intra |= 1 << i;
3555 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3556 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3557 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3558 block_cbp |= pat << (i << 2);
3559 if (!v->ttmbf && ttmb < 8)
3566 for (i = 0; i < 6; i++) {
3567 v->mb_type[0][s->block_index[i]] = 0;
3568 s->dc_val[0][s->block_index[i]] = 0;
3570 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3571 s->current_picture.f.qscale_table[mb_pos] = 0;
3572 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3575 } else { // 4MV mode
3576 if (!skipped /* unskipped MB */) {
3577 int intra_count = 0, coded_inter = 0;
3578 int is_intra[6], is_coded[6];
3580 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3581 for (i = 0; i < 6; i++) {
3582 val = ((cbp >> (5 - i)) & 1);
3583 s->dc_val[0][s->block_index[i]] = 0;
3590 GET_MVDATA(dmv_x, dmv_y);
3592 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3594 vc1_mc_4mv_luma(v, i, 0);
3595 intra_count += s->mb_intra;
3596 is_intra[i] = s->mb_intra;
3597 is_coded[i] = mb_has_coeffs;
3600 is_intra[i] = (intra_count >= 3);
3604 vc1_mc_4mv_chroma(v, 0);
3605 v->mb_type[0][s->block_index[i]] = is_intra[i];
3607 coded_inter = !is_intra[i] & is_coded[i];
3609 // if there are no coded blocks then don't do anything more
3611 if (!intra_count && !coded_inter)
3614 s->current_picture.f.qscale_table[mb_pos] = mquant;
3615 /* test if block is intra and has pred */
3618 for (i = 0; i < 6; i++)
3620 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3621 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3627 s->ac_pred = get_bits1(gb);
3631 if (!v->ttmbf && coded_inter)
3632 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3633 for (i = 0; i < 6; i++) {
3635 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3636 s->mb_intra = is_intra[i];
3638 /* check if prediction blocks A and C are available */
3639 v->a_avail = v->c_avail = 0;
3640 if (i == 2 || i == 3 || !s->first_slice_line)
3641 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3642 if (i == 1 || i == 3 || s->mb_x)
3643 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3645 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3646 (i & 4) ? v->codingset2 : v->codingset);
3647 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3649 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3651 for (j = 0; j < 64; j++)
3652 s->block[i][j] <<= 1;
3653 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3654 (i & 4) ? s->uvlinesize : s->linesize);
3655 if (v->pq >= 9 && v->overlap) {
3657 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3659 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3661 block_cbp |= 0xF << (i << 2);
3662 block_intra |= 1 << i;
3663 } else if (is_coded[i]) {
3664 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3665 first_block, s->dest[dst_idx] + off,
3666 (i & 4) ? s->uvlinesize : s->linesize,
3667 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3669 block_cbp |= pat << (i << 2);
3670 if (!v->ttmbf && ttmb < 8)
3675 } else { // skipped MB
3677 s->current_picture.f.qscale_table[mb_pos] = 0;
3678 for (i = 0; i < 6; i++) {
3679 v->mb_type[0][s->block_index[i]] = 0;
3680 s->dc_val[0][s->block_index[i]] = 0;
3682 for (i = 0; i < 4; i++) {
3683 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3684 vc1_mc_4mv_luma(v, i, 0);
3686 vc1_mc_4mv_chroma(v, 0);
3687 s->current_picture.f.qscale_table[mb_pos] = 0;
3691 v->cbp[s->mb_x] = block_cbp;
3692 v->ttblk[s->mb_x] = block_tt;
3693 v->is_intra[s->mb_x] = block_intra;
3698 /* Decode one macroblock in an interlaced frame p picture */
3700 static int vc1_decode_p_mb_intfr(VC1Context *v)
3702 MpegEncContext *s = &v->s;
3703 GetBitContext *gb = &s->gb;
3705 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3706 int cbp = 0; /* cbp decoding stuff */
3707 int mqdiff, mquant; /* MB quantization */
3708 int ttmb = v->ttfrm; /* MB Transform type */
3710 int mb_has_coeffs = 1; /* last_flag */
3711 int dmv_x, dmv_y; /* Differential MV components */
3712 int val; /* temp value */
3713 int first_block = 1;
3715 int skipped, fourmv = 0, twomv = 0;
3716 int block_cbp = 0, pat, block_tt = 0;
3717 int idx_mbmode = 0, mvbp;
3718 int stride_y, fieldtx;
3720 mquant = v->pq; /* Lossy initialization */
3723 skipped = get_bits1(gb);
3725 skipped = v->s.mbskip_table[mb_pos];
3727 if (v->fourmvswitch)
3728 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3730 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3731 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3732 /* store the motion vector type in a flag (useful later) */
3733 case MV_PMODE_INTFR_4MV:
3735 v->blk_mv_type[s->block_index[0]] = 0;
3736 v->blk_mv_type[s->block_index[1]] = 0;
3737 v->blk_mv_type[s->block_index[2]] = 0;
3738 v->blk_mv_type[s->block_index[3]] = 0;
3740 case MV_PMODE_INTFR_4MV_FIELD:
3742 v->blk_mv_type[s->block_index[0]] = 1;
3743 v->blk_mv_type[s->block_index[1]] = 1;
3744 v->blk_mv_type[s->block_index[2]] = 1;
3745 v->blk_mv_type[s->block_index[3]] = 1;
3747 case MV_PMODE_INTFR_2MV_FIELD:
3749 v->blk_mv_type[s->block_index[0]] = 1;
3750 v->blk_mv_type[s->block_index[1]] = 1;
3751 v->blk_mv_type[s->block_index[2]] = 1;
3752 v->blk_mv_type[s->block_index[3]] = 1;
3754 case MV_PMODE_INTFR_1MV:
3755 v->blk_mv_type[s->block_index[0]] = 0;
3756 v->blk_mv_type[s->block_index[1]] = 0;
3757 v->blk_mv_type[s->block_index[2]] = 0;
3758 v->blk_mv_type[s->block_index[3]] = 0;
3761 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3762 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3763 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3764 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
3765 s->mb_intra = v->is_intra[s->mb_x] = 1;
3766 for (i = 0; i < 6; i++)
3767 v->mb_type[0][s->block_index[i]] = 1;
3768 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3769 mb_has_coeffs = get_bits1(gb);
3771 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3772 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3774 s->current_picture.f.qscale_table[mb_pos] = mquant;
3775 /* Set DC scale - y and c use the same (not sure if necessary here) */
3776 s->y_dc_scale = s->y_dc_scale_table[mquant];
3777 s->c_dc_scale = s->c_dc_scale_table[mquant];
3779 for (i = 0; i < 6; i++) {
3780 s->dc_val[0][s->block_index[i]] = 0;
3782 val = ((cbp >> (5 - i)) & 1);
3783 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3784 v->a_avail = v->c_avail = 0;
3785 if (i == 2 || i == 3 || !s->first_slice_line)
3786 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3787 if (i == 1 || i == 3 || s->mb_x)
3788 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3790 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3791 (i & 4) ? v->codingset2 : v->codingset);
3792 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3793 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3795 stride_y = s->linesize << fieldtx;
3796 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3798 stride_y = s->uvlinesize;
3801 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3805 } else { // inter MB
3806 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3808 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3809 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3810 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3812 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3813 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3814 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3817 s->mb_intra = v->is_intra[s->mb_x] = 0;
3818 for (i = 0; i < 6; i++)
3819 v->mb_type[0][s->block_index[i]] = 0;
3820 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3821 /* for all motion vector read MVDATA and motion compensate each block */
3825 for (i = 0; i < 6; i++) {
3828 val = ((mvbp >> (3 - i)) & 1);
3830 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3832 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3833 vc1_mc_4mv_luma(v, i, 0);
3834 } else if (i == 4) {
3835 vc1_mc_4mv_chroma4(v);
3842 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3844 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3845 vc1_mc_4mv_luma(v, 0, 0);
3846 vc1_mc_4mv_luma(v, 1, 0);
3849 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3851 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3852 vc1_mc_4mv_luma(v, 2, 0);
3853 vc1_mc_4mv_luma(v, 3, 0);
3854 vc1_mc_4mv_chroma4(v);
3856 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3859 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3861 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3865 GET_MQUANT(); // p. 227
3866 s->current_picture.f.qscale_table[mb_pos] = mquant;
3867 if (!v->ttmbf && cbp)
3868 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3869 for (i = 0; i < 6; i++) {
3870 s->dc_val[0][s->block_index[i]] = 0;
3872 val = ((cbp >> (5 - i)) & 1);
3874 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3876 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3878 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3879 first_block, s->dest[dst_idx] + off,
3880 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3881 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3882 block_cbp |= pat << (i << 2);
3883 if (!v->ttmbf && ttmb < 8)
3890 s->mb_intra = v->is_intra[s->mb_x] = 0;
3891 for (i = 0; i < 6; i++) {
3892 v->mb_type[0][s->block_index[i]] = 0;
3893 s->dc_val[0][s->block_index[i]] = 0;
3895 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3896 s->current_picture.f.qscale_table[mb_pos] = 0;
3897 v->blk_mv_type[s->block_index[0]] = 0;
3898 v->blk_mv_type[s->block_index[1]] = 0;
3899 v->blk_mv_type[s->block_index[2]] = 0;
3900 v->blk_mv_type[s->block_index[3]] = 0;
3901 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3904 if (s->mb_x == s->mb_width - 1)
3905 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3909 static int vc1_decode_p_mb_intfi(VC1Context *v)
3911 MpegEncContext *s = &v->s;
3912 GetBitContext *gb = &s->gb;
3914 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3915 int cbp = 0; /* cbp decoding stuff */
3916 int mqdiff, mquant; /* MB quantization */
3917 int ttmb = v->ttfrm; /* MB Transform type */
3919 int mb_has_coeffs = 1; /* last_flag */
3920 int dmv_x, dmv_y; /* Differential MV components */
3921 int val; /* temp values */
3922 int first_block = 1;
3925 int block_cbp = 0, pat, block_tt = 0;
3928 mquant = v->pq; /* Lossy initialization */
3930 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3931 if (idx_mbmode <= 1) { // intra MB
3932 s->mb_intra = v->is_intra[s->mb_x] = 1;
3933 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3934 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3935 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3937 s->current_picture.f.qscale_table[mb_pos] = mquant;
3938 /* Set DC scale - y and c use the same (not sure if necessary here) */
3939 s->y_dc_scale = s->y_dc_scale_table[mquant];
3940 s->c_dc_scale = s->c_dc_scale_table[mquant];
3941 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3942 mb_has_coeffs = idx_mbmode & 1;
3944 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3946 for (i = 0; i < 6; i++) {
3947 s->dc_val[0][s->block_index[i]] = 0;
3948 v->mb_type[0][s->block_index[i]] = 1;
3950 val = ((cbp >> (5 - i)) & 1);
3951 v->a_avail = v->c_avail = 0;
3952 if (i == 2 || i == 3 || !s->first_slice_line)
3953 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3954 if (i == 1 || i == 3 || s->mb_x)
3955 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3957 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3958 (i & 4) ? v->codingset2 : v->codingset);
3959 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3961 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3962 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3963 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
3964 // TODO: loop filter
3967 s->mb_intra = v->is_intra[s->mb_x] = 0;
3968 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3969 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3970 if (idx_mbmode <= 5) { // 1-MV
3971 dmv_x = dmv_y = pred_flag = 0;
3972 if (idx_mbmode & 1) {
3973 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3975 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3977 mb_has_coeffs = !(idx_mbmode & 2);
3979 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3980 for (i = 0; i < 6; i++) {
3982 dmv_x = dmv_y = pred_flag = 0;
3983 val = ((v->fourmvbp >> (3 - i)) & 1);
3985 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3987 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3988 vc1_mc_4mv_luma(v, i, 0);
3990 vc1_mc_4mv_chroma(v, 0);
3992 mb_has_coeffs = idx_mbmode & 1;
3995 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3999 s->current_picture.f.qscale_table[mb_pos] = mquant;
4000 if (!v->ttmbf && cbp) {
4001 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4004 for (i = 0; i < 6; i++) {
4005 s->dc_val[0][s->block_index[i]] = 0;
4007 val = ((cbp >> (5 - i)) & 1);
4008 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4010 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4011 first_block, s->dest[dst_idx] + off,
4012 (i & 4) ? s->uvlinesize : s->linesize,
4013 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
4015 block_cbp |= pat << (i << 2);
4016 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4021 if (s->mb_x == s->mb_width - 1)
4022 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4026 /** Decode one B-frame MB (in Main profile)
4028 static void vc1_decode_b_mb(VC1Context *v)
4030 MpegEncContext *s = &v->s;
4031 GetBitContext *gb = &s->gb;
4033 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4034 int cbp = 0; /* cbp decoding stuff */
4035 int mqdiff, mquant; /* MB quantization */
4036 int ttmb = v->ttfrm; /* MB Transform type */
4037 int mb_has_coeffs = 0; /* last_flag */
4038 int index, index1; /* LUT indexes */
4039 int val, sign; /* temp values */
4040 int first_block = 1;
4042 int skipped, direct;
4043 int dmv_x[2], dmv_y[2];
4044 int bmvtype = BMV_TYPE_BACKWARD;
4046 mquant = v->pq; /* lossy initialization */
4050 direct = get_bits1(gb);
4052 direct = v->direct_mb_plane[mb_pos];
4054 skipped = get_bits1(gb);
4056 skipped = v->s.mbskip_table[mb_pos];
4058 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4059 for (i = 0; i < 6; i++) {
4060 v->mb_type[0][s->block_index[i]] = 0;
4061 s->dc_val[0][s->block_index[i]] = 0;
4063 s->current_picture.f.qscale_table[mb_pos] = 0;
4067 GET_MVDATA(dmv_x[0], dmv_y[0]);
4068 dmv_x[1] = dmv_x[0];
4069 dmv_y[1] = dmv_y[0];
4071 if (skipped || !s->mb_intra) {
4072 bmvtype = decode012(gb);
4075 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4078 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4081 bmvtype = BMV_TYPE_INTERPOLATED;
4082 dmv_x[0] = dmv_y[0] = 0;
4086 for (i = 0; i < 6; i++)
4087 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4091 bmvtype = BMV_TYPE_INTERPOLATED;
4092 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4093 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4097 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4100 s->current_picture.f.qscale_table[mb_pos] = mquant;
4102 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4103 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4104 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4105 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4107 if (!mb_has_coeffs && !s->mb_intra) {
4108 /* no coded blocks - effectively skipped */
4109 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4110 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4113 if (s->mb_intra && !mb_has_coeffs) {
4115 s->current_picture.f.qscale_table[mb_pos] = mquant;
4116 s->ac_pred = get_bits1(gb);
4118 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4120 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4121 GET_MVDATA(dmv_x[0], dmv_y[0]);
4122 if (!mb_has_coeffs) {
4123 /* interpolated skipped block */
4124 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4125 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4129 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4131 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4134 s->ac_pred = get_bits1(gb);
4135 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4137 s->current_picture.f.qscale_table[mb_pos] = mquant;
4138 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4139 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4143 for (i = 0; i < 6; i++) {
4144 s->dc_val[0][s->block_index[i]] = 0;
4146 val = ((cbp >> (5 - i)) & 1);
4147 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4148 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4150 /* check if prediction blocks A and C are available */
4151 v->a_avail = v->c_avail = 0;
4152 if (i == 2 || i == 3 || !s->first_slice_line)
4153 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4154 if (i == 1 || i == 3 || s->mb_x)
4155 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4157 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4158 (i & 4) ? v->codingset2 : v->codingset);
4159 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4161 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4163 for (j = 0; j < 64; j++)
4164 s->block[i][j] <<= 1;
4165 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4167 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4168 first_block, s->dest[dst_idx] + off,
4169 (i & 4) ? s->uvlinesize : s->linesize,
4170 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4171 if (!v->ttmbf && ttmb < 8)
4178 /** Decode one B-frame MB (in interlaced field B picture)
4180 static void vc1_decode_b_mb_intfi(VC1Context *v)
4182 MpegEncContext *s = &v->s;
4183 GetBitContext *gb = &s->gb;
4185 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4186 int cbp = 0; /* cbp decoding stuff */
4187 int mqdiff, mquant; /* MB quantization */
4188 int ttmb = v->ttfrm; /* MB Transform type */
4189 int mb_has_coeffs = 0; /* last_flag */
4190 int val; /* temp value */
4191 int first_block = 1;
4194 int dmv_x[2], dmv_y[2], pred_flag[2];
4195 int bmvtype = BMV_TYPE_BACKWARD;
4196 int idx_mbmode, interpmvp;
4198 mquant = v->pq; /* Lossy initialization */
4201 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4202 if (idx_mbmode <= 1) { // intra MB
4203 s->mb_intra = v->is_intra[s->mb_x] = 1;
4204 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4205 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4206 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4208 s->current_picture.f.qscale_table[mb_pos] = mquant;
4209 /* Set DC scale - y and c use the same (not sure if necessary here) */
4210 s->y_dc_scale = s->y_dc_scale_table[mquant];
4211 s->c_dc_scale = s->c_dc_scale_table[mquant];
4212 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4213 mb_has_coeffs = idx_mbmode & 1;
4215 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4217 for (i = 0; i < 6; i++) {
4218 s->dc_val[0][s->block_index[i]] = 0;
4220 val = ((cbp >> (5 - i)) & 1);
4221 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4222 v->a_avail = v->c_avail = 0;
4223 if (i == 2 || i == 3 || !s->first_slice_line)
4224 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4225 if (i == 1 || i == 3 || s->mb_x)
4226 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4228 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4229 (i & 4) ? v->codingset2 : v->codingset);
4230 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4232 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4234 for (j = 0; j < 64; j++)
4235 s->block[i][j] <<= 1;
4236 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4237 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4238 // TODO: yet to perform loop filter
4241 s->mb_intra = v->is_intra[s->mb_x] = 0;
4242 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4243 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4245 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4247 fwd = v->forward_mb_plane[mb_pos];
4248 if (idx_mbmode <= 5) { // 1-MV
4249 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4250 pred_flag[0] = pred_flag[1] = 0;
4252 bmvtype = BMV_TYPE_FORWARD;
4254 bmvtype = decode012(gb);
4257 bmvtype = BMV_TYPE_BACKWARD;
4260 bmvtype = BMV_TYPE_DIRECT;
4263 bmvtype = BMV_TYPE_INTERPOLATED;
4264 interpmvp = get_bits1(gb);
4267 v->bmvtype = bmvtype;
4268 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4269 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4271 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4272 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4274 if (bmvtype == BMV_TYPE_DIRECT) {
4275 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4276 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4278 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4279 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4280 mb_has_coeffs = !(idx_mbmode & 2);
4283 bmvtype = BMV_TYPE_FORWARD;
4284 v->bmvtype = bmvtype;
4285 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4286 for (i = 0; i < 6; i++) {
4288 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4289 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4290 val = ((v->fourmvbp >> (3 - i)) & 1);
4292 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4293 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4294 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4296 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4297 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4299 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4301 mb_has_coeffs = idx_mbmode & 1;
4304 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4308 s->current_picture.f.qscale_table[mb_pos] = mquant;
4309 if (!v->ttmbf && cbp) {
4310 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4313 for (i = 0; i < 6; i++) {
4314 s->dc_val[0][s->block_index[i]] = 0;
4316 val = ((cbp >> (5 - i)) & 1);
4317 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4319 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4320 first_block, s->dest[dst_idx] + off,
4321 (i & 4) ? s->uvlinesize : s->linesize,
4322 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4323 if (!v->ttmbf && ttmb < 8)
4331 /** Decode blocks of I-frame
4333 static void vc1_decode_i_blocks(VC1Context *v)
4336 MpegEncContext *s = &v->s;
4341 /* select codingmode used for VLC tables selection */
4342 switch (v->y_ac_table_index) {
4344 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4347 v->codingset = CS_HIGH_MOT_INTRA;
4350 v->codingset = CS_MID_RATE_INTRA;
4354 switch (v->c_ac_table_index) {
4356 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4359 v->codingset2 = CS_HIGH_MOT_INTER;
4362 v->codingset2 = CS_MID_RATE_INTER;
4366 /* Set DC scale - y and c use the same */
4367 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4368 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4371 s->mb_x = s->mb_y = 0;
4373 s->first_slice_line = 1;
4374 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4376 init_block_index(v);
4377 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4379 ff_update_block_index(s);
4380 dst[0] = s->dest[0];
4381 dst[1] = dst[0] + 8;
4382 dst[2] = s->dest[0] + s->linesize * 8;
4383 dst[3] = dst[2] + 8;
4384 dst[4] = s->dest[1];
4385 dst[5] = s->dest[2];
4386 s->dsp.clear_blocks(s->block[0]);
4387 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4388 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
4389 s->current_picture.f.qscale_table[mb_pos] = v->pq;
4390 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4391 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4393 // do actual MB decoding and displaying
4394 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4395 v->s.ac_pred = get_bits1(&v->s.gb);
4397 for (k = 0; k < 6; k++) {
4398 val = ((cbp >> (5 - k)) & 1);
4401 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4405 cbp |= val << (5 - k);
4407 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4409 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4411 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4412 if (v->pq >= 9 && v->overlap) {
4414 for (j = 0; j < 64; j++)
4415 s->block[k][j] <<= 1;
4416 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4419 for (j = 0; j < 64; j++)
4420 s->block[k][j] = (s->block[k][j] - 64) << 1;
4421 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4425 if (v->pq >= 9 && v->overlap) {
4427 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4428 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4429 if (!(s->flags & CODEC_FLAG_GRAY)) {
4430 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4431 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4434 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4435 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4436 if (!s->first_slice_line) {
4437 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4438 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4439 if (!(s->flags & CODEC_FLAG_GRAY)) {
4440 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4441 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4444 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4445 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4447 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4449 if (get_bits_count(&s->gb) > v->bits) {
4450 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4451 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4452 get_bits_count(&s->gb), v->bits);
4456 if (!v->s.loop_filter)
4457 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4459 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4461 s->first_slice_line = 0;
4463 if (v->s.loop_filter)
4464 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4466 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4467 * profile, these only differ are when decoding MSS2 rectangles. */
4468 ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4471 /** Decode blocks of I-frame for advanced profile
4473 static void vc1_decode_i_blocks_adv(VC1Context *v)
4476 MpegEncContext *s = &v->s;
4482 GetBitContext *gb = &s->gb;
4484 /* select codingmode used for VLC tables selection */
4485 switch (v->y_ac_table_index) {
4487 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4490 v->codingset = CS_HIGH_MOT_INTRA;
4493 v->codingset = CS_MID_RATE_INTRA;
4497 switch (v->c_ac_table_index) {
4499 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4502 v->codingset2 = CS_HIGH_MOT_INTER;
4505 v->codingset2 = CS_MID_RATE_INTER;
4510 s->mb_x = s->mb_y = 0;
4512 s->first_slice_line = 1;
4513 s->mb_y = s->start_mb_y;
4514 if (s->start_mb_y) {
4516 init_block_index(v);
4517 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4518 (1 + s->b8_stride) * sizeof(*s->coded_block));
4520 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4522 init_block_index(v);
4523 for (;s->mb_x < s->mb_width; s->mb_x++) {
4524 int16_t (*block)[64] = v->block[v->cur_blk_idx];
4525 ff_update_block_index(s);
4526 s->dsp.clear_blocks(block[0]);
4527 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4528 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4529 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4530 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4532 // do actual MB decoding and displaying
4533 if (v->fieldtx_is_raw)
4534 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4535 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4536 if ( v->acpred_is_raw)
4537 v->s.ac_pred = get_bits1(&v->s.gb);
4539 v->s.ac_pred = v->acpred_plane[mb_pos];
4541 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4542 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4546 s->current_picture.f.qscale_table[mb_pos] = mquant;
4547 /* Set DC scale - y and c use the same */
4548 s->y_dc_scale = s->y_dc_scale_table[mquant];
4549 s->c_dc_scale = s->c_dc_scale_table[mquant];
4551 for (k = 0; k < 6; k++) {
4552 val = ((cbp >> (5 - k)) & 1);
4555 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4559 cbp |= val << (5 - k);
4561 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4562 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4564 vc1_decode_i_block_adv(v, block[k], k, val,
4565 (k < 4) ? v->codingset : v->codingset2, mquant);
4567 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4569 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4572 vc1_smooth_overlap_filter_iblk(v);
4573 vc1_put_signed_blocks_clamped(v);
4574 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4576 if (get_bits_count(&s->gb) > v->bits) {
4577 // TODO: may need modification to handle slice coding
4578 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4579 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4580 get_bits_count(&s->gb), v->bits);
4584 if (!v->s.loop_filter)
4585 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4587 ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4588 s->first_slice_line = 0;
4591 /* raw bottom MB row */
4593 init_block_index(v);
4595 for (;s->mb_x < s->mb_width; s->mb_x++) {
4596 ff_update_block_index(s);
4597 vc1_put_signed_blocks_clamped(v);
4598 if (v->s.loop_filter)
4599 vc1_loop_filter_iblk_delayed(v, v->pq);
4601 if (v->s.loop_filter)
4602 ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4603 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4604 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4607 static void vc1_decode_p_blocks(VC1Context *v)
4609 MpegEncContext *s = &v->s;
4610 int apply_loop_filter;
4612 /* select codingmode used for VLC tables selection */
4613 switch (v->c_ac_table_index) {
4615 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4618 v->codingset = CS_HIGH_MOT_INTRA;
4621 v->codingset = CS_MID_RATE_INTRA;
4625 switch (v->c_ac_table_index) {
4627 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4630 v->codingset2 = CS_HIGH_MOT_INTER;
4633 v->codingset2 = CS_MID_RATE_INTER;
4637 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
4638 s->first_slice_line = 1;
4639 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
4640 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4642 init_block_index(v);
4643 for (; s->mb_x < s->mb_width; s->mb_x++) {
4644 ff_update_block_index(s);
4646 if (v->fcm == ILACE_FIELD)
4647 vc1_decode_p_mb_intfi(v);
4648 else if (v->fcm == ILACE_FRAME)
4649 vc1_decode_p_mb_intfr(v);
4650 else vc1_decode_p_mb(v);
4651 if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == PROGRESSIVE)
4652 vc1_apply_p_loop_filter(v);
4653 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4654 // TODO: may need modification to handle slice coding
4655 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4656 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4657 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4661 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
4662 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
4663 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4664 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
4665 if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4666 s->first_slice_line = 0;
4668 if (apply_loop_filter && v->fcm == PROGRESSIVE) {
4670 init_block_index(v);
4671 for (; s->mb_x < s->mb_width; s->mb_x++) {
4672 ff_update_block_index(s);
4673 vc1_apply_p_loop_filter(v);
4676 if (s->end_mb_y >= s->start_mb_y)
4677 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4678 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4679 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4682 static void vc1_decode_b_blocks(VC1Context *v)
4684 MpegEncContext *s = &v->s;
4686 /* select codingmode used for VLC tables selection */
4687 switch (v->c_ac_table_index) {
4689 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4692 v->codingset = CS_HIGH_MOT_INTRA;
4695 v->codingset = CS_MID_RATE_INTRA;
4699 switch (v->c_ac_table_index) {
4701 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4704 v->codingset2 = CS_HIGH_MOT_INTER;
4707 v->codingset2 = CS_MID_RATE_INTER;
4711 s->first_slice_line = 1;
4712 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4714 init_block_index(v);
4715 for (; s->mb_x < s->mb_width; s->mb_x++) {
4716 ff_update_block_index(s);
4718 if (v->fcm == ILACE_FIELD)
4719 vc1_decode_b_mb_intfi(v);
4722 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4723 // TODO: may need modification to handle slice coding
4724 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4725 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4726 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4729 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4731 if (!v->s.loop_filter)
4732 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4734 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4735 s->first_slice_line = 0;
4737 if (v->s.loop_filter)
4738 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4739 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4740 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4743 static void vc1_decode_skip_blocks(VC1Context *v)
4745 MpegEncContext *s = &v->s;
4747 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
4748 s->first_slice_line = 1;
4749 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4751 init_block_index(v);
4752 ff_update_block_index(s);
4753 if (s->last_picture.f.data[0]) {
4754 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4755 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4756 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4758 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4759 s->first_slice_line = 0;
4761 s->pict_type = AV_PICTURE_TYPE_P;
4764 void ff_vc1_decode_blocks(VC1Context *v)
4767 v->s.esc3_level_length = 0;
4769 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
4772 v->left_blk_idx = -1;
4773 v->topleft_blk_idx = 1;
4775 switch (v->s.pict_type) {
4776 case AV_PICTURE_TYPE_I:
4777 if (v->profile == PROFILE_ADVANCED)
4778 vc1_decode_i_blocks_adv(v);
4780 vc1_decode_i_blocks(v);
4782 case AV_PICTURE_TYPE_P:
4783 if (v->p_frame_skipped)
4784 vc1_decode_skip_blocks(v);
4786 vc1_decode_p_blocks(v);
4788 case AV_PICTURE_TYPE_B:
4790 if (v->profile == PROFILE_ADVANCED)
4791 vc1_decode_i_blocks_adv(v);
4793 vc1_decode_i_blocks(v);
4795 vc1_decode_b_blocks(v);
4801 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
4805 * Transform coefficients for both sprites in 16.16 fixed point format,
4806 * in the order they appear in the bitstream:
4808 * rotation 1 (unused)
4810 * rotation 2 (unused)
4817 int effect_type, effect_flag;
4818 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
4819 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
4822 static inline int get_fp_val(GetBitContext* gb)
4824 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
4827 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
4831 switch (get_bits(gb, 2)) {
4834 c[2] = get_fp_val(gb);
4838 c[0] = c[4] = get_fp_val(gb);
4839 c[2] = get_fp_val(gb);
4842 c[0] = get_fp_val(gb);
4843 c[2] = get_fp_val(gb);
4844 c[4] = get_fp_val(gb);
4847 c[0] = get_fp_val(gb);
4848 c[1] = get_fp_val(gb);
4849 c[2] = get_fp_val(gb);
4850 c[3] = get_fp_val(gb);
4851 c[4] = get_fp_val(gb);
4854 c[5] = get_fp_val(gb);
4856 c[6] = get_fp_val(gb);
4861 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
4863 AVCodecContext *avctx = v->s.avctx;
4866 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4867 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
4868 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
4869 av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
4870 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
4871 for (i = 0; i < 7; i++)
4872 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
4873 sd->coefs[sprite][i] / (1<<16),
4874 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
4875 av_log(avctx, AV_LOG_DEBUG, "\n");
4879 if (sd->effect_type = get_bits_long(gb, 30)) {
4880 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
4882 vc1_sprite_parse_transform(gb, sd->effect_params1);
4885 vc1_sprite_parse_transform(gb, sd->effect_params1);
4886 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
4889 for (i = 0; i < sd->effect_pcount1; i++)
4890 sd->effect_params1[i] = get_fp_val(gb);
4892 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
4893 // effect 13 is simple alpha blending and matches the opacity above
4894 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
4895 for (i = 0; i < sd->effect_pcount1; i++)
4896 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4897 sd->effect_params1[i] / (1 << 16),
4898 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
4899 av_log(avctx, AV_LOG_DEBUG, "\n");
4902 sd->effect_pcount2 = get_bits(gb, 16);
4903 if (sd->effect_pcount2 > 10) {
4904 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
4906 } else if (sd->effect_pcount2) {
4908 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
4909 while (++i < sd->effect_pcount2) {
4910 sd->effect_params2[i] = get_fp_val(gb);
4911 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4912 sd->effect_params2[i] / (1 << 16),
4913 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
4915 av_log(avctx, AV_LOG_DEBUG, "\n");
4918 if (sd->effect_flag = get_bits1(gb))
4919 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4921 if (get_bits_count(gb) >= gb->size_in_bits +
4922 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
4923 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4924 if (get_bits_count(gb) < gb->size_in_bits - 8)
4925 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4928 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
4930 int i, plane, row, sprite;
4931 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
4932 uint8_t* src_h[2][2];
4933 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
4935 MpegEncContext *s = &v->s;
4937 for (i = 0; i < 2; i++) {
4938 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
4939 xadv[i] = sd->coefs[i][0];
4940 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
4941 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
4943 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
4944 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
4946 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
4948 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
4949 int width = v->output_width>>!!plane;
4951 for (row = 0; row < v->output_height>>!!plane; row++) {
4952 uint8_t *dst = v->sprite_output_frame.data[plane] +
4953 v->sprite_output_frame.linesize[plane] * row;
4955 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4956 uint8_t *iplane = s->current_picture.f.data[plane];
4957 int iline = s->current_picture.f.linesize[plane];
4958 int ycoord = yoff[sprite] + yadv[sprite] * row;
4959 int yline = ycoord >> 16;
4961 ysub[sprite] = ycoord & 0xFFFF;
4963 iplane = s->last_picture.f.data[plane];
4964 iline = s->last_picture.f.linesize[plane];
4966 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
4967 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4968 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
4970 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
4972 if (sr_cache[sprite][0] != yline) {
4973 if (sr_cache[sprite][1] == yline) {
4974 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
4975 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
4977 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
4978 sr_cache[sprite][0] = yline;
4981 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4982 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
4983 iplane + next_line, xoff[sprite],
4984 xadv[sprite], width);
4985 sr_cache[sprite][1] = yline + 1;
4987 src_h[sprite][0] = v->sr_rows[sprite][0];
4988 src_h[sprite][1] = v->sr_rows[sprite][1];
4992 if (!v->two_sprites) {
4994 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
4996 memcpy(dst, src_h[0][0], width);
4999 if (ysub[0] && ysub[1]) {
5000 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5001 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5002 } else if (ysub[0]) {
5003 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5004 src_h[1][0], alpha, width);
5005 } else if (ysub[1]) {
5006 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5007 src_h[0][0], (1<<16)-1-alpha, width);
5009 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5015 for (i = 0; i < 2; i++) {
5025 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5027 MpegEncContext *s = &v->s;
5028 AVCodecContext *avctx = s->avctx;
5031 vc1_parse_sprites(v, gb, &sd);
5033 if (!s->current_picture.f.data[0]) {
5034 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5038 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5039 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5043 if (v->sprite_output_frame.data[0])
5044 avctx->release_buffer(avctx, &v->sprite_output_frame);
5046 v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5047 v->sprite_output_frame.reference = 0;
5048 if (ff_get_buffer(avctx, &v->sprite_output_frame) < 0) {
5049 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5053 vc1_draw_sprites(v, &sd);
5058 static void vc1_sprite_flush(AVCodecContext *avctx)
5060 VC1Context *v = avctx->priv_data;
5061 MpegEncContext *s = &v->s;
5062 AVFrame *f = &s->current_picture.f;
5065 /* Windows Media Image codecs have a convergence interval of two keyframes.
5066 Since we can't enforce it, clear to black the missing sprite. This is
5067 wrong but it looks better than doing nothing. */
5070 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5071 for (i = 0; i < v->sprite_height>>!!plane; i++)
5072 memset(f->data[plane] + i * f->linesize[plane],
5073 plane ? 128 : 0, f->linesize[plane]);
5078 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5080 MpegEncContext *s = &v->s;
5083 /* Allocate mb bitplanes */
5084 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5085 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5086 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5087 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5088 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5089 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5091 v->n_allocated_blks = s->mb_width + 2;
5092 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5093 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5094 v->cbp = v->cbp_base + s->mb_stride;
5095 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5096 v->ttblk = v->ttblk_base + s->mb_stride;
5097 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5098 v->is_intra = v->is_intra_base + s->mb_stride;
5099 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5100 v->luma_mv = v->luma_mv_base + s->mb_stride;
5102 /* allocate block type info in that way so it could be used with s->block_index[] */
5103 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5104 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5105 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5106 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5108 /* allocate memory to store block level MV info */
5109 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5110 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5111 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5112 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5113 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5114 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5115 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
5116 v->mv_f_last[1] = v->mv_f_last[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5117 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5118 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5119 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);
5121 /* Init coded blocks info */
5122 if (v->profile == PROFILE_ADVANCED) {
5123 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5125 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5129 ff_intrax8_common_init(&v->x8,s);
5131 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5132 for (i = 0; i < 4; i++)
5133 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5136 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5137 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5144 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5147 for (i = 0; i < 64; i++) {
5148 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5149 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5150 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5151 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5152 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5153 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5159 /** Initialize a VC1/WMV3 decoder
5160 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5161 * @todo TODO: Decypher remaining bits in extra_data
5163 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5165 VC1Context *v = avctx->priv_data;
5166 MpegEncContext *s = &v->s;
5169 /* save the container output size for WMImage */
5170 v->output_width = avctx->width;
5171 v->output_height = avctx->height;
5173 if (!avctx->extradata_size || !avctx->extradata)
5175 if (!(avctx->flags & CODEC_FLAG_GRAY))
5176 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5178 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5179 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5181 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5182 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5184 if (ff_vc1_init_common(v) < 0)
5186 // ensure static VLC tables are initialized
5187 if (ff_msmpeg4_decode_init(avctx) < 0)
5189 if (ff_vc1_decode_init_alloc_tables(v) < 0)
5191 // Hack to ensure the above functions will be called
5192 // again once we know all necessary settings.
5193 // That this is necessary might indicate a bug.
5194 ff_vc1_decode_end(avctx);
5196 ff_h264chroma_init(&v->h264chroma, 8);
5197 ff_vc1dsp_init(&v->vc1dsp);
5199 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5202 // looks like WMV3 has a sequence header stored in the extradata
5203 // advanced sequence header may be before the first frame
5204 // the last byte of the extradata is a version number, 1 for the
5205 // samples we can decode
5207 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5209 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5212 count = avctx->extradata_size*8 - get_bits_count(&gb);
5214 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5215 count, get_bits(&gb, count));
5216 } else if (count < 0) {
5217 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5219 } else { // VC1/WVC1/WVP2
5220 const uint8_t *start = avctx->extradata;
5221 uint8_t *end = avctx->extradata + avctx->extradata_size;
5222 const uint8_t *next;
5223 int size, buf2_size;
5224 uint8_t *buf2 = NULL;
5225 int seq_initialized = 0, ep_initialized = 0;
5227 if (avctx->extradata_size < 16) {
5228 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5232 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5233 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5235 for (; next < end; start = next) {
5236 next = find_next_marker(start + 4, end);
5237 size = next - start - 4;
5240 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5241 init_get_bits(&gb, buf2, buf2_size * 8);
5242 switch (AV_RB32(start)) {
5243 case VC1_CODE_SEQHDR:
5244 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5248 seq_initialized = 1;
5250 case VC1_CODE_ENTRYPOINT:
5251 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5260 if (!seq_initialized || !ep_initialized) {
5261 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5264 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5267 avctx->profile = v->profile;
5268 if (v->profile == PROFILE_ADVANCED)
5269 avctx->level = v->level;
5271 avctx->has_b_frames = !!avctx->max_b_frames;
5273 s->mb_width = (avctx->coded_width + 15) >> 4;
5274 s->mb_height = (avctx->coded_height + 15) >> 4;
5276 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5277 ff_vc1_init_transposed_scantables(v);
5279 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5284 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5285 v->sprite_width = avctx->coded_width;
5286 v->sprite_height = avctx->coded_height;
5288 avctx->coded_width = avctx->width = v->output_width;
5289 avctx->coded_height = avctx->height = v->output_height;
5291 // prevent 16.16 overflows
5292 if (v->sprite_width > 1 << 14 ||
5293 v->sprite_height > 1 << 14 ||
5294 v->output_width > 1 << 14 ||
5295 v->output_height > 1 << 14) return -1;
5300 /** Close a VC1/WMV3 decoder
5301 * @warning Initial try at using MpegEncContext stuff
5303 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5305 VC1Context *v = avctx->priv_data;
5308 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5309 && v->sprite_output_frame.data[0])
5310 avctx->release_buffer(avctx, &v->sprite_output_frame);
5311 for (i = 0; i < 4; i++)
5312 av_freep(&v->sr_rows[i >> 1][i & 1]);
5313 av_freep(&v->hrd_rate);
5314 av_freep(&v->hrd_buffer);
5315 ff_MPV_common_end(&v->s);
5316 av_freep(&v->mv_type_mb_plane);
5317 av_freep(&v->direct_mb_plane);
5318 av_freep(&v->forward_mb_plane);
5319 av_freep(&v->fieldtx_plane);
5320 av_freep(&v->acpred_plane);
5321 av_freep(&v->over_flags_plane);
5322 av_freep(&v->mb_type_base);
5323 av_freep(&v->blk_mv_type_base);
5324 av_freep(&v->mv_f_base);
5325 av_freep(&v->mv_f_last_base);
5326 av_freep(&v->mv_f_next_base);
5327 av_freep(&v->block);
5328 av_freep(&v->cbp_base);
5329 av_freep(&v->ttblk_base);
5330 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5331 av_freep(&v->luma_mv_base);
5332 ff_intrax8_common_end(&v->x8);
5337 /** Decode a VC1/WMV3 frame
5338 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5340 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5341 int *got_frame, AVPacket *avpkt)
5343 const uint8_t *buf = avpkt->data;
5344 int buf_size = avpkt->size, n_slices = 0, i;
5345 VC1Context *v = avctx->priv_data;
5346 MpegEncContext *s = &v->s;
5347 AVFrame *pict = data;
5348 uint8_t *buf2 = NULL;
5349 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
5350 int mb_height, n_slices1=-1;
5355 } *slices = NULL, *tmp;
5357 v->second_field = 0;
5359 if(s->flags & CODEC_FLAG_LOW_DELAY)
5362 /* no supplementary picture */
5363 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5364 /* special case for last picture */
5365 if (s->low_delay == 0 && s->next_picture_ptr) {
5366 *pict = s->next_picture_ptr->f;
5367 s->next_picture_ptr = NULL;
5375 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5376 if (v->profile < PROFILE_ADVANCED)
5377 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5379 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5382 //for advanced profile we may need to parse and unescape data
5383 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5385 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5387 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5388 const uint8_t *start, *end, *next;
5392 for (start = buf, end = buf + buf_size; next < end; start = next) {
5393 next = find_next_marker(start + 4, end);
5394 size = next - start - 4;
5395 if (size <= 0) continue;
5396 switch (AV_RB32(start)) {
5397 case VC1_CODE_FRAME:
5398 if (avctx->hwaccel ||
5399 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5401 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5403 case VC1_CODE_FIELD: {
5405 if (avctx->hwaccel ||
5406 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5407 buf_start_second_field = start;
5408 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5412 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5413 if (!slices[n_slices].buf)
5415 buf_size3 = vc1_unescape_buffer(start + 4, size,
5416 slices[n_slices].buf);
5417 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5419 /* assuming that the field marker is at the exact middle,
5420 hope it's correct */
5421 slices[n_slices].mby_start = s->mb_height >> 1;
5422 n_slices1 = n_slices - 1; // index of the last slice of the first field
5426 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5427 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5428 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5429 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5431 case VC1_CODE_SLICE: {
5433 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5437 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5438 if (!slices[n_slices].buf)
5440 buf_size3 = vc1_unescape_buffer(start + 4, size,
5441 slices[n_slices].buf);
5442 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5444 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5450 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5451 const uint8_t *divider;
5454 divider = find_next_marker(buf, buf + buf_size);
5455 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5456 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5458 } else { // found field marker, unescape second field
5459 if (avctx->hwaccel ||
5460 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5461 buf_start_second_field = divider;
5462 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5466 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5467 if (!slices[n_slices].buf)
5469 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5470 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5472 slices[n_slices].mby_start = s->mb_height >> 1;
5473 n_slices1 = n_slices - 1;
5476 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5478 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5480 init_get_bits(&s->gb, buf2, buf_size2*8);
5482 init_get_bits(&s->gb, buf, buf_size*8);
5484 if (v->res_sprite) {
5485 v->new_sprite = !get_bits1(&s->gb);
5486 v->two_sprites = get_bits1(&s->gb);
5487 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5488 we're using the sprite compositor. These are intentionally kept separate
5489 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5490 the vc1 one for WVP2 */
5491 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5492 if (v->new_sprite) {
5493 // switch AVCodecContext parameters to those of the sprites
5494 avctx->width = avctx->coded_width = v->sprite_width;
5495 avctx->height = avctx->coded_height = v->sprite_height;
5502 if (s->context_initialized &&
5503 (s->width != avctx->coded_width ||
5504 s->height != avctx->coded_height)) {
5505 ff_vc1_decode_end(avctx);
5508 if (!s->context_initialized) {
5509 if (ff_msmpeg4_decode_init(avctx) < 0 || ff_vc1_decode_init_alloc_tables(v) < 0)
5512 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5514 if (v->profile == PROFILE_ADVANCED) {
5515 if(avctx->coded_width<=1 || avctx->coded_height<=1)
5517 s->h_edge_pos = avctx->coded_width;
5518 s->v_edge_pos = avctx->coded_height;
5522 /* We need to set current_picture_ptr before reading the header,
5523 * otherwise we cannot store anything in there. */
5524 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5525 int i = ff_find_unused_picture(s, 0);
5528 s->current_picture_ptr = &s->picture[i];
5531 // do parse frame header
5532 v->pic_header_flag = 0;
5533 v->first_pic_header_flag = 1;
5534 if (v->profile < PROFILE_ADVANCED) {
5535 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5539 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5543 v->first_pic_header_flag = 0;
5545 if (avctx->debug & FF_DEBUG_PICT_INFO)
5546 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
5548 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5549 && s->pict_type != AV_PICTURE_TYPE_I) {
5550 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5554 if ((s->mb_height >> v->field_mode) == 0) {
5555 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
5559 // process pulldown flags
5560 s->current_picture_ptr->f.repeat_pict = 0;
5561 // Pulldown flags are only valid when 'broadcast' has been set.
5562 // So ticks_per_frame will be 2
5565 s->current_picture_ptr->f.repeat_pict = 1;
5566 } else if (v->rptfrm) {
5568 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5571 // for skipping the frame
5572 s->current_picture.f.pict_type = s->pict_type;
5573 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5575 /* skip B-frames if we don't have reference frames */
5576 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
5579 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5580 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5581 avctx->skip_frame >= AVDISCARD_ALL) {
5585 if (s->next_p_frame_damaged) {
5586 if (s->pict_type == AV_PICTURE_TYPE_B)
5589 s->next_p_frame_damaged = 0;
5592 if (ff_MPV_frame_start(s, avctx) < 0) {
5596 v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
5597 v->s.current_picture_ptr->f.top_field_first = v->tff;
5599 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5600 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5602 if ((CONFIG_VC1_VDPAU_DECODER)
5603 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5604 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5605 else if (avctx->hwaccel) {
5606 if (v->field_mode && buf_start_second_field) {
5607 // decode first field
5608 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
5609 if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
5611 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
5613 if (avctx->hwaccel->end_frame(avctx) < 0)
5616 // decode second field
5617 s->gb = slices[n_slices1 + 1].gb;
5618 s->picture_structure = PICT_TOP_FIELD + v->tff;
5619 v->second_field = 1;
5620 v->pic_header_flag = 0;
5621 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5622 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
5625 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
5627 if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
5629 if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
5631 if (avctx->hwaccel->end_frame(avctx) < 0)
5634 s->picture_structure = PICT_FRAME;
5635 if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5637 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5639 if (avctx->hwaccel->end_frame(avctx) < 0)
5645 if (v->fcm == ILACE_FRAME && s->pict_type == AV_PICTURE_TYPE_B)
5646 goto err; // This codepath is still incomplete thus it is disabled
5648 ff_mpeg_er_frame_start(s);
5650 v->bits = buf_size * 8;
5651 v->end_mb_x = s->mb_width;
5652 if (v->field_mode) {
5654 s->current_picture.f.linesize[0] <<= 1;
5655 s->current_picture.f.linesize[1] <<= 1;
5656 s->current_picture.f.linesize[2] <<= 1;
5658 s->uvlinesize <<= 1;
5659 tmp[0] = v->mv_f_last[0];
5660 tmp[1] = v->mv_f_last[1];
5661 v->mv_f_last[0] = v->mv_f_next[0];
5662 v->mv_f_last[1] = v->mv_f_next[1];
5663 v->mv_f_next[0] = v->mv_f[0];
5664 v->mv_f_next[1] = v->mv_f[1];
5665 v->mv_f[0] = tmp[0];
5666 v->mv_f[1] = tmp[1];
5668 mb_height = s->mb_height >> v->field_mode;
5669 for (i = 0; i <= n_slices; i++) {
5670 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5671 if (v->field_mode <= 0) {
5672 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
5673 "picture boundary (%d >= %d)\n", i,
5674 slices[i - 1].mby_start, mb_height);
5677 v->second_field = 1;
5678 v->blocks_off = s->b8_stride * (s->mb_height&~1);
5679 v->mb_off = s->mb_stride * s->mb_height >> 1;
5681 v->second_field = 0;
5686 v->pic_header_flag = 0;
5687 if (v->field_mode && i == n_slices1 + 2) {
5688 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
5689 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
5692 } else if (get_bits1(&s->gb)) {
5693 v->pic_header_flag = 1;
5694 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
5695 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
5702 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5703 if (!v->field_mode || v->second_field)
5704 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5706 if (i >= n_slices) {
5707 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
5710 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5712 if (s->end_mb_y <= s->start_mb_y) {
5713 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
5716 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
5717 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
5720 ff_vc1_decode_blocks(v);
5722 s->gb = slices[i].gb;
5724 if (v->field_mode) {
5725 v->second_field = 0;
5726 if (s->pict_type == AV_PICTURE_TYPE_B) {
5727 memcpy(v->mv_f_base, v->mv_f_next_base,
5728 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5730 s->current_picture.f.linesize[0] >>= 1;
5731 s->current_picture.f.linesize[1] >>= 1;
5732 s->current_picture.f.linesize[2] >>= 1;
5734 s->uvlinesize >>= 1;
5736 av_dlog(s->avctx, "Consumed %i/%i bits\n",
5737 get_bits_count(&s->gb), s->gb.size_in_bits);
5738 // if (get_bits_count(&s->gb) > buf_size * 8)
5740 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
5743 ff_er_frame_end(&s->er);
5746 ff_MPV_frame_end(s);
5748 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5750 avctx->width = avctx->coded_width = v->output_width;
5751 avctx->height = avctx->coded_height = v->output_height;
5752 if (avctx->skip_frame >= AVDISCARD_NONREF)
5754 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5755 if (vc1_decode_sprites(v, &s->gb))
5758 *pict = v->sprite_output_frame;
5761 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5762 *pict = s->current_picture_ptr->f;
5763 } else if (s->last_picture_ptr != NULL) {
5764 *pict = s->last_picture_ptr->f;
5766 if (s->last_picture_ptr || s->low_delay) {
5768 ff_print_debug_info(s, pict);
5774 for (i = 0; i < n_slices; i++)
5775 av_free(slices[i].buf);
5781 for (i = 0; i < n_slices; i++)
5782 av_free(slices[i].buf);
5788 static const AVProfile profiles[] = {
5789 { FF_PROFILE_VC1_SIMPLE, "Simple" },
5790 { FF_PROFILE_VC1_MAIN, "Main" },
5791 { FF_PROFILE_VC1_COMPLEX, "Complex" },
5792 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5793 { FF_PROFILE_UNKNOWN },
5796 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
5798 AV_PIX_FMT_DXVA2_VLD,
5801 AV_PIX_FMT_VAAPI_VLD,
5810 AVCodec ff_vc1_decoder = {
5812 .type = AVMEDIA_TYPE_VIDEO,
5813 .id = AV_CODEC_ID_VC1,
5814 .priv_data_size = sizeof(VC1Context),
5815 .init = vc1_decode_init,
5816 .close = ff_vc1_decode_end,
5817 .decode = vc1_decode_frame,
5818 .flush = ff_mpeg_flush,
5819 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5820 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5821 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
5822 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5825 #if CONFIG_WMV3_DECODER
5826 AVCodec ff_wmv3_decoder = {
5828 .type = AVMEDIA_TYPE_VIDEO,
5829 .id = AV_CODEC_ID_WMV3,
5830 .priv_data_size = sizeof(VC1Context),
5831 .init = vc1_decode_init,
5832 .close = ff_vc1_decode_end,
5833 .decode = vc1_decode_frame,
5834 .flush = ff_mpeg_flush,
5835 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5836 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5837 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
5838 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5842 #if CONFIG_WMV3_VDPAU_DECODER
5843 AVCodec ff_wmv3_vdpau_decoder = {
5844 .name = "wmv3_vdpau",
5845 .type = AVMEDIA_TYPE_VIDEO,
5846 .id = AV_CODEC_ID_WMV3,
5847 .priv_data_size = sizeof(VC1Context),
5848 .init = vc1_decode_init,
5849 .close = ff_vc1_decode_end,
5850 .decode = vc1_decode_frame,
5851 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5852 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5853 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
5854 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5858 #if CONFIG_VC1_VDPAU_DECODER
5859 AVCodec ff_vc1_vdpau_decoder = {
5860 .name = "vc1_vdpau",
5861 .type = AVMEDIA_TYPE_VIDEO,
5862 .id = AV_CODEC_ID_VC1,
5863 .priv_data_size = sizeof(VC1Context),
5864 .init = vc1_decode_init,
5865 .close = ff_vc1_decode_end,
5866 .decode = vc1_decode_frame,
5867 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5868 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5869 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
5870 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5874 #if CONFIG_WMV3IMAGE_DECODER
5875 AVCodec ff_wmv3image_decoder = {
5876 .name = "wmv3image",
5877 .type = AVMEDIA_TYPE_VIDEO,
5878 .id = AV_CODEC_ID_WMV3IMAGE,
5879 .priv_data_size = sizeof(VC1Context),
5880 .init = vc1_decode_init,
5881 .close = ff_vc1_decode_end,
5882 .decode = vc1_decode_frame,
5883 .capabilities = CODEC_CAP_DR1,
5884 .flush = vc1_sprite_flush,
5885 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5886 .pix_fmts = ff_pixfmt_list_420
5890 #if CONFIG_VC1IMAGE_DECODER
5891 AVCodec ff_vc1image_decoder = {
5893 .type = AVMEDIA_TYPE_VIDEO,
5894 .id = AV_CODEC_ID_VC1IMAGE,
5895 .priv_data_size = sizeof(VC1Context),
5896 .init = vc1_decode_init,
5897 .close = ff_vc1_decode_end,
5898 .decode = vc1_decode_frame,
5899 .capabilities = CODEC_CAP_DR1,
5900 .flush = vc1_sprite_flush,
5901 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5902 .pix_fmts = ff_pixfmt_list_420