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 Libav.
9 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
31 #include "error_resilience.h"
32 #include "mpegvideo.h"
34 #include "h264chroma.h"
37 #include "vc1acdata.h"
38 #include "msmpeg4data.h"
41 #include "vdpau_internal.h"
46 #define MB_INTRA_VLC_BITS 9
50 // offset tables for interlaced picture MVDATA decoding
51 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
52 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
54 /***********************************************************************/
56 * @name VC-1 Bitplane decoding
74 /** @} */ //imode defines
77 /** @} */ //Bitplane group
79 static void vc1_put_signed_blocks_clamped(VC1Context *v)
81 MpegEncContext *s = &v->s;
82 int topleft_mb_pos, top_mb_pos;
83 int stride_y, fieldtx = 0;
86 /* The put pixels loop is always one MB row behind the decoding loop,
87 * because we can only put pixels when overlap filtering is done, and
88 * for filtering of the bottom edge of a MB, we need the next MB row
90 * Within the row, the put pixels loop is also one MB col behind the
91 * decoding loop. The reason for this is again, because for filtering
92 * of the right MB edge, we need the next MB present. */
93 if (!s->first_slice_line) {
95 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
96 if (v->fcm == ILACE_FRAME)
97 fieldtx = v->fieldtx_plane[topleft_mb_pos];
98 stride_y = s->linesize << fieldtx;
99 v_dist = (16 - fieldtx) >> (fieldtx == 0);
100 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
101 s->dest[0] - 16 * s->linesize - 16,
103 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
104 s->dest[0] - 16 * s->linesize - 8,
106 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
107 s->dest[0] - v_dist * s->linesize - 16,
109 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
110 s->dest[0] - v_dist * s->linesize - 8,
112 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
113 s->dest[1] - 8 * s->uvlinesize - 8,
115 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
116 s->dest[2] - 8 * s->uvlinesize - 8,
119 if (s->mb_x == s->mb_width - 1) {
120 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
121 if (v->fcm == ILACE_FRAME)
122 fieldtx = v->fieldtx_plane[top_mb_pos];
123 stride_y = s->linesize << fieldtx;
124 v_dist = fieldtx ? 15 : 8;
125 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
126 s->dest[0] - 16 * s->linesize,
128 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
129 s->dest[0] - 16 * s->linesize + 8,
131 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
132 s->dest[0] - v_dist * s->linesize,
134 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
135 s->dest[0] - v_dist * s->linesize + 8,
137 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
138 s->dest[1] - 8 * s->uvlinesize,
140 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
141 s->dest[2] - 8 * s->uvlinesize,
146 #define inc_blk_idx(idx) do { \
148 if (idx >= v->n_allocated_blks) \
152 inc_blk_idx(v->topleft_blk_idx);
153 inc_blk_idx(v->top_blk_idx);
154 inc_blk_idx(v->left_blk_idx);
155 inc_blk_idx(v->cur_blk_idx);
158 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
160 MpegEncContext *s = &v->s;
162 if (!s->first_slice_line) {
163 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
165 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
166 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
167 for (j = 0; j < 2; j++) {
168 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
170 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
173 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
175 if (s->mb_y == s->end_mb_y - 1) {
177 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
178 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
179 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
181 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
185 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
187 MpegEncContext *s = &v->s;
190 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
191 * means it runs two rows/cols behind the decoding loop. */
192 if (!s->first_slice_line) {
194 if (s->mb_y >= s->start_mb_y + 2) {
195 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
198 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
199 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
200 for (j = 0; j < 2; j++) {
201 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
203 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
207 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
210 if (s->mb_x == s->mb_width - 1) {
211 if (s->mb_y >= s->start_mb_y + 2) {
212 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
215 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
216 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
217 for (j = 0; j < 2; j++) {
218 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
220 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
224 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
227 if (s->mb_y == s->end_mb_y) {
230 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
231 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
233 for (j = 0; j < 2; j++) {
234 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
239 if (s->mb_x == s->mb_width - 1) {
241 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
242 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
244 for (j = 0; j < 2; j++) {
245 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
253 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
255 MpegEncContext *s = &v->s;
258 if (v->condover == CONDOVER_NONE)
261 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
263 /* Within a MB, the horizontal overlap always runs before the vertical.
264 * To accomplish that, we run the H on left and internal borders of the
265 * currently decoded MB. Then, we wait for the next overlap iteration
266 * to do H overlap on the right edge of this MB, before moving over and
267 * running the V overlap. Therefore, the V overlap makes us trail by one
268 * MB col and the H overlap filter makes us trail by one MB row. This
269 * is reflected in the time at which we run the put_pixels loop. */
270 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
271 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
272 v->over_flags_plane[mb_pos - 1])) {
273 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
274 v->block[v->cur_blk_idx][0]);
275 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
276 v->block[v->cur_blk_idx][2]);
277 if (!(s->flags & CODEC_FLAG_GRAY)) {
278 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
279 v->block[v->cur_blk_idx][4]);
280 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
281 v->block[v->cur_blk_idx][5]);
284 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
285 v->block[v->cur_blk_idx][1]);
286 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
287 v->block[v->cur_blk_idx][3]);
289 if (s->mb_x == s->mb_width - 1) {
290 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
291 v->over_flags_plane[mb_pos - s->mb_stride])) {
292 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
293 v->block[v->cur_blk_idx][0]);
294 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
295 v->block[v->cur_blk_idx][1]);
296 if (!(s->flags & CODEC_FLAG_GRAY)) {
297 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
298 v->block[v->cur_blk_idx][4]);
299 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
300 v->block[v->cur_blk_idx][5]);
303 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
304 v->block[v->cur_blk_idx][2]);
305 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
306 v->block[v->cur_blk_idx][3]);
309 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
310 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
311 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
312 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
313 v->block[v->left_blk_idx][0]);
314 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
315 v->block[v->left_blk_idx][1]);
316 if (!(s->flags & CODEC_FLAG_GRAY)) {
317 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
318 v->block[v->left_blk_idx][4]);
319 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
320 v->block[v->left_blk_idx][5]);
323 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
324 v->block[v->left_blk_idx][2]);
325 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
326 v->block[v->left_blk_idx][3]);
330 /** Do motion compensation over 1 macroblock
331 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
333 static void vc1_mc_1mv(VC1Context *v, int dir)
335 MpegEncContext *s = &v->s;
336 H264ChromaContext *h264chroma = &v->h264chroma;
337 uint8_t *srcY, *srcU, *srcV;
338 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
340 int v_edge_pos = s->v_edge_pos >> v->field_mode;
342 if ((!v->field_mode ||
343 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
344 !v->s.last_picture.f.data[0])
347 mx = s->mv[dir][0][0];
348 my = s->mv[dir][0][1];
350 // store motion vectors for further use in B frames
351 if (s->pict_type == AV_PICTURE_TYPE_P) {
352 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
353 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
356 uvmx = (mx + ((mx & 3) == 3)) >> 1;
357 uvmy = (my + ((my & 3) == 3)) >> 1;
358 v->luma_mv[s->mb_x][0] = uvmx;
359 v->luma_mv[s->mb_x][1] = uvmy;
362 v->cur_field_type != v->ref_field_type[dir]) {
363 my = my - 2 + 4 * v->cur_field_type;
364 uvmy = uvmy - 2 + 4 * v->cur_field_type;
367 // fastuvmc shall be ignored for interlaced frame picture
368 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
369 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
370 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
372 if (v->field_mode) { // interlaced field picture
374 if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type) {
375 srcY = s->current_picture.f.data[0];
376 srcU = s->current_picture.f.data[1];
377 srcV = s->current_picture.f.data[2];
379 srcY = s->last_picture.f.data[0];
380 srcU = s->last_picture.f.data[1];
381 srcV = s->last_picture.f.data[2];
384 srcY = s->next_picture.f.data[0];
385 srcU = s->next_picture.f.data[1];
386 srcV = s->next_picture.f.data[2];
390 srcY = s->last_picture.f.data[0];
391 srcU = s->last_picture.f.data[1];
392 srcV = s->last_picture.f.data[2];
394 srcY = s->next_picture.f.data[0];
395 srcU = s->next_picture.f.data[1];
396 srcV = s->next_picture.f.data[2];
400 src_x = s->mb_x * 16 + (mx >> 2);
401 src_y = s->mb_y * 16 + (my >> 2);
402 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
403 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
405 if (v->profile != PROFILE_ADVANCED) {
406 src_x = av_clip( src_x, -16, s->mb_width * 16);
407 src_y = av_clip( src_y, -16, s->mb_height * 16);
408 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
409 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
411 src_x = av_clip( src_x, -17, s->avctx->coded_width);
412 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
413 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
414 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
417 srcY += src_y * s->linesize + src_x;
418 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
419 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
421 if (v->field_mode && v->ref_field_type[dir]) {
422 srcY += s->current_picture_ptr->f.linesize[0];
423 srcU += s->current_picture_ptr->f.linesize[1];
424 srcV += s->current_picture_ptr->f.linesize[2];
427 /* for grayscale we should not try to read from unknown area */
428 if (s->flags & CODEC_FLAG_GRAY) {
429 srcU = s->edge_emu_buffer + 18 * s->linesize;
430 srcV = s->edge_emu_buffer + 18 * s->linesize;
433 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
434 || s->h_edge_pos < 22 || v_edge_pos < 22
435 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
436 || (unsigned)(src_y - 1) > v_edge_pos - (my&3) - 16 - 3) {
437 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
439 srcY -= s->mspel * (1 + s->linesize);
440 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
441 17 + s->mspel * 2, 17 + s->mspel * 2,
442 src_x - s->mspel, src_y - s->mspel,
443 s->h_edge_pos, v_edge_pos);
444 srcY = s->edge_emu_buffer;
445 s->vdsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
446 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
447 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
448 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
451 /* if we deal with range reduction we need to scale source blocks */
452 if (v->rangeredfrm) {
457 for (j = 0; j < 17 + s->mspel * 2; j++) {
458 for (i = 0; i < 17 + s->mspel * 2; i++)
459 src[i] = ((src[i] - 128) >> 1) + 128;
464 for (j = 0; j < 9; j++) {
465 for (i = 0; i < 9; i++) {
466 src[i] = ((src[i] - 128) >> 1) + 128;
467 src2[i] = ((src2[i] - 128) >> 1) + 128;
469 src += s->uvlinesize;
470 src2 += s->uvlinesize;
473 /* if we deal with intensity compensation we need to scale source blocks */
474 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
479 for (j = 0; j < 17 + s->mspel * 2; j++) {
480 for (i = 0; i < 17 + s->mspel * 2; i++)
481 src[i] = v->luty[src[i]];
486 for (j = 0; j < 9; j++) {
487 for (i = 0; i < 9; i++) {
488 src[i] = v->lutuv[src[i]];
489 src2[i] = v->lutuv[src2[i]];
491 src += s->uvlinesize;
492 src2 += s->uvlinesize;
495 srcY += s->mspel * (1 + s->linesize);
498 if (v->field_mode && v->cur_field_type) {
499 off = s->current_picture_ptr->f.linesize[0];
500 off_uv = s->current_picture_ptr->f.linesize[1];
506 dxy = ((my & 3) << 2) | (mx & 3);
507 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
508 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
509 srcY += s->linesize * 8;
510 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
511 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
512 } else { // hpel mc - always used for luma
513 dxy = (my & 2) | ((mx & 2) >> 1);
515 s->hdsp.put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
517 s->hdsp.put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
520 if (s->flags & CODEC_FLAG_GRAY) return;
521 /* Chroma MC always uses qpel bilinear */
522 uvmx = (uvmx & 3) << 1;
523 uvmy = (uvmy & 3) << 1;
525 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
526 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
528 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
529 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
533 static inline int median4(int a, int b, int c, int d)
536 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
537 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
539 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
540 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
544 /** Do motion compensation for 4-MV macroblock - luminance block
546 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
548 MpegEncContext *s = &v->s;
550 int dxy, mx, my, src_x, src_y;
552 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
553 int v_edge_pos = s->v_edge_pos >> v->field_mode;
555 if ((!v->field_mode ||
556 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
557 !v->s.last_picture.f.data[0])
560 mx = s->mv[dir][n][0];
561 my = s->mv[dir][n][1];
565 if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type)
566 srcY = s->current_picture.f.data[0];
568 srcY = s->last_picture.f.data[0];
570 srcY = s->last_picture.f.data[0];
572 srcY = s->next_picture.f.data[0];
575 if (v->cur_field_type != v->ref_field_type[dir])
576 my = my - 2 + 4 * v->cur_field_type;
579 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
580 int same_count = 0, opp_count = 0, k;
581 int chosen_mv[2][4][2], f;
583 for (k = 0; k < 4; k++) {
584 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
585 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
586 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
590 f = opp_count > same_count;
591 switch (f ? opp_count : same_count) {
593 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
594 chosen_mv[f][2][0], chosen_mv[f][3][0]);
595 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
596 chosen_mv[f][2][1], chosen_mv[f][3][1]);
599 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
600 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
603 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
604 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
607 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
608 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
609 for (k = 0; k < 4; k++)
610 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
613 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
615 int width = s->avctx->coded_width;
616 int height = s->avctx->coded_height >> 1;
617 qx = (s->mb_x * 16) + (mx >> 2);
618 qy = (s->mb_y * 8) + (my >> 3);
623 mx -= 4 * (qx - width);
626 else if (qy > height + 1)
627 my -= 8 * (qy - height - 1);
630 if ((v->fcm == ILACE_FRAME) && fieldmv)
631 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
633 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
634 if (v->field_mode && v->cur_field_type)
635 off += s->current_picture_ptr->f.linesize[0];
637 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
639 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
641 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
643 if (v->profile != PROFILE_ADVANCED) {
644 src_x = av_clip(src_x, -16, s->mb_width * 16);
645 src_y = av_clip(src_y, -16, s->mb_height * 16);
647 src_x = av_clip(src_x, -17, s->avctx->coded_width);
648 if (v->fcm == ILACE_FRAME) {
650 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
652 src_y = av_clip(src_y, -18, s->avctx->coded_height);
654 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
658 srcY += src_y * s->linesize + src_x;
659 if (v->field_mode && v->ref_field_type[dir])
660 srcY += s->current_picture_ptr->f.linesize[0];
662 if (fieldmv && !(src_y & 1))
664 if (fieldmv && (src_y & 1) && src_y < 4)
666 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
667 || s->h_edge_pos < 13 || v_edge_pos < 23
668 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
669 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
670 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
671 /* check emulate edge stride and offset */
672 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
673 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
674 src_x - s->mspel, src_y - (s->mspel << fieldmv),
675 s->h_edge_pos, v_edge_pos);
676 srcY = s->edge_emu_buffer;
677 /* if we deal with range reduction we need to scale source blocks */
678 if (v->rangeredfrm) {
683 for (j = 0; j < 9 + s->mspel * 2; j++) {
684 for (i = 0; i < 9 + s->mspel * 2; i++)
685 src[i] = ((src[i] - 128) >> 1) + 128;
686 src += s->linesize << fieldmv;
689 /* if we deal with intensity compensation we need to scale source blocks */
690 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
695 for (j = 0; j < 9 + s->mspel * 2; j++) {
696 for (i = 0; i < 9 + s->mspel * 2; i++)
697 src[i] = v->luty[src[i]];
698 src += s->linesize << fieldmv;
701 srcY += s->mspel * (1 + (s->linesize << fieldmv));
705 dxy = ((my & 3) << 2) | (mx & 3);
706 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
707 } else { // hpel mc - always used for luma
708 dxy = (my & 2) | ((mx & 2) >> 1);
710 s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
712 s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
716 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
719 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
721 idx = ((a[3] != flag) << 3)
722 | ((a[2] != flag) << 2)
723 | ((a[1] != flag) << 1)
726 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
727 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
729 } else if (count[idx] == 1) {
732 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
733 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
736 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
737 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
740 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
741 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
744 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
745 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
748 } else if (count[idx] == 2) {
750 for (i = 0; i < 3; i++)
755 for (i = t1 + 1; i < 4; i++)
760 *tx = (mvx[t1] + mvx[t2]) / 2;
761 *ty = (mvy[t1] + mvy[t2]) / 2;
769 /** Do motion compensation for 4-MV macroblock - both chroma blocks
771 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
773 MpegEncContext *s = &v->s;
774 H264ChromaContext *h264chroma = &v->h264chroma;
775 uint8_t *srcU, *srcV;
776 int uvmx, uvmy, uvsrc_x, uvsrc_y;
777 int k, tx = 0, ty = 0;
778 int mvx[4], mvy[4], intra[4], mv_f[4];
780 int chroma_ref_type = v->cur_field_type, off = 0;
781 int v_edge_pos = s->v_edge_pos >> v->field_mode;
783 if (!v->field_mode && !v->s.last_picture.f.data[0])
785 if (s->flags & CODEC_FLAG_GRAY)
788 for (k = 0; k < 4; k++) {
789 mvx[k] = s->mv[dir][k][0];
790 mvy[k] = s->mv[dir][k][1];
791 intra[k] = v->mb_type[0][s->block_index[k]];
793 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
796 /* calculate chroma MV vector from four luma MVs */
797 if (!v->field_mode || (v->field_mode && !v->numref)) {
798 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
799 chroma_ref_type = v->reffield;
801 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
802 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
803 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
804 return; //no need to do MC for intra blocks
808 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
810 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
812 chroma_ref_type = !v->cur_field_type;
814 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
816 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
817 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
818 uvmx = (tx + ((tx & 3) == 3)) >> 1;
819 uvmy = (ty + ((ty & 3) == 3)) >> 1;
821 v->luma_mv[s->mb_x][0] = uvmx;
822 v->luma_mv[s->mb_x][1] = uvmy;
825 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
826 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
828 // Field conversion bias
829 if (v->cur_field_type != chroma_ref_type)
830 uvmy += 2 - 4 * chroma_ref_type;
832 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
833 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
835 if (v->profile != PROFILE_ADVANCED) {
836 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
837 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
839 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
840 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
845 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
846 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
847 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
849 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
850 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
853 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
854 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
857 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
858 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
862 if (chroma_ref_type) {
863 srcU += s->current_picture_ptr->f.linesize[1];
864 srcV += s->current_picture_ptr->f.linesize[2];
866 off = v->cur_field_type ? s->current_picture_ptr->f.linesize[1] : 0;
869 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
870 || s->h_edge_pos < 18 || v_edge_pos < 18
871 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
872 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
873 s->vdsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
874 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
875 s->h_edge_pos >> 1, v_edge_pos >> 1);
876 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
877 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
878 s->h_edge_pos >> 1, v_edge_pos >> 1);
879 srcU = s->edge_emu_buffer;
880 srcV = s->edge_emu_buffer + 16;
882 /* if we deal with range reduction we need to scale source blocks */
883 if (v->rangeredfrm) {
889 for (j = 0; j < 9; j++) {
890 for (i = 0; i < 9; i++) {
891 src[i] = ((src[i] - 128) >> 1) + 128;
892 src2[i] = ((src2[i] - 128) >> 1) + 128;
894 src += s->uvlinesize;
895 src2 += s->uvlinesize;
898 /* if we deal with intensity compensation we need to scale source blocks */
899 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
905 for (j = 0; j < 9; j++) {
906 for (i = 0; i < 9; i++) {
907 src[i] = v->lutuv[src[i]];
908 src2[i] = v->lutuv[src2[i]];
910 src += s->uvlinesize;
911 src2 += s->uvlinesize;
916 /* Chroma MC always uses qpel bilinear */
917 uvmx = (uvmx & 3) << 1;
918 uvmy = (uvmy & 3) << 1;
920 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
921 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
923 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
924 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
928 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
930 static void vc1_mc_4mv_chroma4(VC1Context *v)
932 MpegEncContext *s = &v->s;
933 H264ChromaContext *h264chroma = &v->h264chroma;
934 uint8_t *srcU, *srcV;
935 int uvsrc_x, uvsrc_y;
936 int uvmx_field[4], uvmy_field[4];
938 int fieldmv = v->blk_mv_type[s->block_index[0]];
939 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
940 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
941 int v_edge_pos = s->v_edge_pos >> 1;
943 if (!v->s.last_picture.f.data[0])
945 if (s->flags & CODEC_FLAG_GRAY)
948 for (i = 0; i < 4; i++) {
950 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
953 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
955 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
958 for (i = 0; i < 4; i++) {
959 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
960 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
961 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
962 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
963 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
964 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
965 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
966 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
967 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
968 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
970 if (fieldmv && !(uvsrc_y & 1))
972 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
974 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
975 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
976 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
977 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
978 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
979 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
980 s->h_edge_pos >> 1, v_edge_pos);
981 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
982 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
983 s->h_edge_pos >> 1, v_edge_pos);
984 srcU = s->edge_emu_buffer;
985 srcV = s->edge_emu_buffer + 16;
987 /* if we deal with intensity compensation we need to scale source blocks */
988 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
994 for (j = 0; j < 5; j++) {
995 for (i = 0; i < 5; i++) {
996 src[i] = v->lutuv[src[i]];
997 src2[i] = v->lutuv[src2[i]];
999 src += s->uvlinesize << 1;
1000 src2 += s->uvlinesize << 1;
1005 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1006 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1008 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]);
1009 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]);
1014 /***********************************************************************/
1016 * @name VC-1 Block-level functions
1017 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1023 * @brief Get macroblock-level quantizer scale
1025 #define GET_MQUANT() \
1026 if (v->dquantfrm) { \
1028 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1029 if (v->dqbilevel) { \
1030 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1032 mqdiff = get_bits(gb, 3); \
1034 mquant = v->pq + mqdiff; \
1036 mquant = get_bits(gb, 5); \
1039 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1040 edges = 1 << v->dqsbedge; \
1041 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1042 edges = (3 << v->dqsbedge) % 15; \
1043 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1045 if ((edges&1) && !s->mb_x) \
1046 mquant = v->altpq; \
1047 if ((edges&2) && s->first_slice_line) \
1048 mquant = v->altpq; \
1049 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1050 mquant = v->altpq; \
1051 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1052 mquant = v->altpq; \
1053 if (!mquant || mquant > 31) { \
1054 av_log(v->s.avctx, AV_LOG_ERROR, \
1055 "Overriding invalid mquant %d\n", mquant); \
1061 * @def GET_MVDATA(_dmv_x, _dmv_y)
1062 * @brief Get MV differentials
1063 * @see MVDATA decoding from 8.3.5.2, p(1)20
1064 * @param _dmv_x Horizontal differential for decoded MV
1065 * @param _dmv_y Vertical differential for decoded MV
1067 #define GET_MVDATA(_dmv_x, _dmv_y) \
1068 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1069 VC1_MV_DIFF_VLC_BITS, 2); \
1071 mb_has_coeffs = 1; \
1074 mb_has_coeffs = 0; \
1077 _dmv_x = _dmv_y = 0; \
1078 } else if (index == 35) { \
1079 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1080 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1081 } else if (index == 36) { \
1086 index1 = index % 6; \
1087 if (!s->quarter_sample && index1 == 5) val = 1; \
1089 if (size_table[index1] - val > 0) \
1090 val = get_bits(gb, size_table[index1] - val); \
1092 sign = 0 - (val&1); \
1093 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1095 index1 = index / 6; \
1096 if (!s->quarter_sample && index1 == 5) val = 1; \
1098 if (size_table[index1] - val > 0) \
1099 val = get_bits(gb, size_table[index1] - val); \
1101 sign = 0 - (val & 1); \
1102 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1105 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1106 int *dmv_y, int *pred_flag)
1109 int extend_x = 0, extend_y = 0;
1110 GetBitContext *gb = &v->s.gb;
1113 const int* offs_tab;
1116 bits = VC1_2REF_MVDATA_VLC_BITS;
1119 bits = VC1_1REF_MVDATA_VLC_BITS;
1122 switch (v->dmvrange) {
1130 extend_x = extend_y = 1;
1133 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1135 *dmv_x = get_bits(gb, v->k_x);
1136 *dmv_y = get_bits(gb, v->k_y);
1139 *pred_flag = *dmv_y & 1;
1140 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1142 *dmv_y = (*dmv_y + (*dmv_y & 1)) >> 1;
1148 offs_tab = offset_table2;
1150 offs_tab = offset_table1;
1151 index1 = (index + 1) % 9;
1153 val = get_bits(gb, index1 + extend_x);
1154 sign = 0 -(val & 1);
1155 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1159 offs_tab = offset_table2;
1161 offs_tab = offset_table1;
1162 index1 = (index + 1) / 9;
1163 if (index1 > v->numref) {
1164 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1165 sign = 0 - (val & 1);
1166 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1169 if (v->numref && pred_flag)
1170 *pred_flag = index1 & 1;
1174 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1176 int scaledvalue, refdist;
1177 int scalesame1, scalesame2;
1178 int scalezone1_x, zone1offset_x;
1179 int table_index = dir ^ v->second_field;
1181 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1182 refdist = v->refdist;
1184 refdist = dir ? v->brfd : v->frfd;
1187 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1188 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1189 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1190 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1195 if (FFABS(n) < scalezone1_x)
1196 scaledvalue = (n * scalesame1) >> 8;
1199 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1201 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1204 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1207 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1209 int scaledvalue, refdist;
1210 int scalesame1, scalesame2;
1211 int scalezone1_y, zone1offset_y;
1212 int table_index = dir ^ v->second_field;
1214 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1215 refdist = v->refdist;
1217 refdist = dir ? v->brfd : v->frfd;
1220 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1221 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1222 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1223 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1228 if (FFABS(n) < scalezone1_y)
1229 scaledvalue = (n * scalesame1) >> 8;
1232 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1234 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1238 if (v->cur_field_type && !v->ref_field_type[dir])
1239 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1241 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1244 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1246 int scalezone1_x, zone1offset_x;
1247 int scaleopp1, scaleopp2, brfd;
1250 brfd = FFMIN(v->brfd, 3);
1251 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1252 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1253 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1254 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1259 if (FFABS(n) < scalezone1_x)
1260 scaledvalue = (n * scaleopp1) >> 8;
1263 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1265 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1268 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1271 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1273 int scalezone1_y, zone1offset_y;
1274 int scaleopp1, scaleopp2, brfd;
1277 brfd = FFMIN(v->brfd, 3);
1278 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1279 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1280 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1281 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1286 if (FFABS(n) < scalezone1_y)
1287 scaledvalue = (n * scaleopp1) >> 8;
1290 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1292 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1295 if (v->cur_field_type && !v->ref_field_type[dir]) {
1296 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1298 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1302 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1305 int brfd, scalesame;
1306 int hpel = 1 - v->s.quarter_sample;
1309 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1311 n = scaleforsame_y(v, i, n, dir) << hpel;
1313 n = scaleforsame_x(v, n, dir) << hpel;
1316 brfd = FFMIN(v->brfd, 3);
1317 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1319 n = (n * scalesame >> 8) << hpel;
1323 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1326 int refdist, scaleopp;
1327 int hpel = 1 - v->s.quarter_sample;
1330 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1332 n = scaleforopp_y(v, n, dir) << hpel;
1334 n = scaleforopp_x(v, n) << hpel;
1337 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1338 refdist = FFMIN(v->refdist, 3);
1340 refdist = dir ? v->brfd : v->frfd;
1341 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1343 n = (n * scaleopp >> 8) << hpel;
1347 /** Predict and set motion vector
1349 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1350 int mv1, int r_x, int r_y, uint8_t* is_intra,
1351 int pred_flag, int dir)
1353 MpegEncContext *s = &v->s;
1354 int xy, wrap, off = 0;
1358 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1359 int opposite, a_f, b_f, c_f;
1360 int16_t field_predA[2];
1361 int16_t field_predB[2];
1362 int16_t field_predC[2];
1363 int a_valid, b_valid, c_valid;
1364 int hybridmv_thresh, y_bias = 0;
1366 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1367 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1371 /* scale MV difference to be quad-pel */
1372 dmv_x <<= 1 - s->quarter_sample;
1373 dmv_y <<= 1 - s->quarter_sample;
1375 wrap = s->b8_stride;
1376 xy = s->block_index[n];
1379 s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
1380 s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
1381 s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
1382 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
1383 if (mv1) { /* duplicate motion data for 1-MV block */
1384 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1385 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1386 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1387 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1388 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1389 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1390 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1391 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1392 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1393 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1394 s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1395 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1396 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1401 C = s->current_picture.motion_val[dir][xy - 1 + v->blocks_off];
1402 A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
1404 if (v->field_mode && mixedmv_pic)
1405 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1407 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1409 //in 4-MV mode different blocks have different B predictor position
1412 off = (s->mb_x > 0) ? -1 : 1;
1415 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1424 B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
1426 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1427 b_valid = a_valid && (s->mb_width > 1);
1428 c_valid = s->mb_x || (n == 1 || n == 3);
1429 if (v->field_mode) {
1430 a_valid = a_valid && !is_intra[xy - wrap];
1431 b_valid = b_valid && !is_intra[xy - wrap + off];
1432 c_valid = c_valid && !is_intra[xy - 1];
1436 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1437 num_oppfield += a_f;
1438 num_samefield += 1 - a_f;
1439 field_predA[0] = A[0];
1440 field_predA[1] = A[1];
1442 field_predA[0] = field_predA[1] = 0;
1446 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1447 num_oppfield += b_f;
1448 num_samefield += 1 - b_f;
1449 field_predB[0] = B[0];
1450 field_predB[1] = B[1];
1452 field_predB[0] = field_predB[1] = 0;
1456 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1457 num_oppfield += c_f;
1458 num_samefield += 1 - c_f;
1459 field_predC[0] = C[0];
1460 field_predC[1] = C[1];
1462 field_predC[0] = field_predC[1] = 0;
1466 if (v->field_mode) {
1468 // REFFIELD determines if the last field or the second-last field is
1469 // to be used as reference
1470 opposite = 1 - v->reffield;
1472 if (num_samefield <= num_oppfield)
1473 opposite = 1 - pred_flag;
1475 opposite = pred_flag;
1480 if (a_valid && !a_f) {
1481 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1482 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1484 if (b_valid && !b_f) {
1485 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1486 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1488 if (c_valid && !c_f) {
1489 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1490 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1492 v->mv_f[dir][xy + v->blocks_off] = 1;
1493 v->ref_field_type[dir] = !v->cur_field_type;
1495 if (a_valid && a_f) {
1496 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1497 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1499 if (b_valid && b_f) {
1500 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1501 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1503 if (c_valid && c_f) {
1504 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1505 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1507 v->mv_f[dir][xy + v->blocks_off] = 0;
1508 v->ref_field_type[dir] = v->cur_field_type;
1512 px = field_predA[0];
1513 py = field_predA[1];
1514 } else if (c_valid) {
1515 px = field_predC[0];
1516 py = field_predC[1];
1517 } else if (b_valid) {
1518 px = field_predB[0];
1519 py = field_predB[1];
1525 if (num_samefield + num_oppfield > 1) {
1526 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1527 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1530 /* Pullback MV as specified in 8.3.5.3.4 */
1531 if (!v->field_mode) {
1533 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1534 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1535 X = (s->mb_width << 6) - 4;
1536 Y = (s->mb_height << 6) - 4;
1538 if (qx + px < -60) px = -60 - qx;
1539 if (qy + py < -60) py = -60 - qy;
1541 if (qx + px < -28) px = -28 - qx;
1542 if (qy + py < -28) py = -28 - qy;
1544 if (qx + px > X) px = X - qx;
1545 if (qy + py > Y) py = Y - qy;
1548 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1549 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1550 hybridmv_thresh = 32;
1551 if (a_valid && c_valid) {
1552 if (is_intra[xy - wrap])
1553 sum = FFABS(px) + FFABS(py);
1555 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1556 if (sum > hybridmv_thresh) {
1557 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1558 px = field_predA[0];
1559 py = field_predA[1];
1561 px = field_predC[0];
1562 py = field_predC[1];
1565 if (is_intra[xy - 1])
1566 sum = FFABS(px) + FFABS(py);
1568 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1569 if (sum > hybridmv_thresh) {
1570 if (get_bits1(&s->gb)) {
1571 px = field_predA[0];
1572 py = field_predA[1];
1574 px = field_predC[0];
1575 py = field_predC[1];
1582 if (v->field_mode && v->numref)
1584 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1586 /* store MV using signed modulus of MV range defined in 4.11 */
1587 s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1588 s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
1589 if (mv1) { /* duplicate motion data for 1-MV block */
1590 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1591 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1592 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1593 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1594 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1595 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1596 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1597 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];
1601 /** Predict and set motion vector for interlaced frame picture MBs
1603 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1604 int mvn, int r_x, int r_y, uint8_t* is_intra)
1606 MpegEncContext *s = &v->s;
1607 int xy, wrap, off = 0;
1608 int A[2], B[2], C[2];
1610 int a_valid = 0, b_valid = 0, c_valid = 0;
1611 int field_a, field_b, field_c; // 0: same, 1: opposit
1612 int total_valid, num_samefield, num_oppfield;
1613 int pos_c, pos_b, n_adj;
1615 wrap = s->b8_stride;
1616 xy = s->block_index[n];
1619 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1620 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1621 s->current_picture.motion_val[1][xy][0] = 0;
1622 s->current_picture.motion_val[1][xy][1] = 0;
1623 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1624 s->current_picture.motion_val[0][xy + 1][0] = 0;
1625 s->current_picture.motion_val[0][xy + 1][1] = 0;
1626 s->current_picture.motion_val[0][xy + wrap][0] = 0;
1627 s->current_picture.motion_val[0][xy + wrap][1] = 0;
1628 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1629 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1630 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1631 s->current_picture.motion_val[1][xy + 1][0] = 0;
1632 s->current_picture.motion_val[1][xy + 1][1] = 0;
1633 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1634 s->current_picture.motion_val[1][xy + wrap][1] = 0;
1635 s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
1636 s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
1641 off = ((n == 0) || (n == 1)) ? 1 : -1;
1643 if (s->mb_x || (n == 1) || (n == 3)) {
1644 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1645 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1646 A[0] = s->current_picture.motion_val[0][xy - 1][0];
1647 A[1] = s->current_picture.motion_val[0][xy - 1][1];
1649 } else { // current block has frame mv and cand. has field MV (so average)
1650 A[0] = (s->current_picture.motion_val[0][xy - 1][0]
1651 + s->current_picture.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1652 A[1] = (s->current_picture.motion_val[0][xy - 1][1]
1653 + s->current_picture.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1656 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1662 /* Predict B and C */
1663 B[0] = B[1] = C[0] = C[1] = 0;
1664 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1665 if (!s->first_slice_line) {
1666 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1669 pos_b = s->block_index[n_adj] - 2 * wrap;
1670 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1671 n_adj = (n & 2) | (n & 1);
1673 B[0] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1674 B[1] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1675 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1676 B[0] = (B[0] + s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1677 B[1] = (B[1] + s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1680 if (s->mb_width > 1) {
1681 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1684 pos_c = s->block_index[2] - 2 * wrap + 2;
1685 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1688 C[0] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1689 C[1] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1690 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1691 C[0] = (1 + C[0] + (s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1692 C[1] = (1 + C[1] + (s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1694 if (s->mb_x == s->mb_width - 1) {
1695 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1698 pos_c = s->block_index[3] - 2 * wrap - 2;
1699 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1702 C[0] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1703 C[1] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1704 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1705 C[0] = (1 + C[0] + s->current_picture.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1706 C[1] = (1 + C[1] + s->current_picture.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1715 pos_b = s->block_index[1];
1717 B[0] = s->current_picture.motion_val[0][pos_b][0];
1718 B[1] = s->current_picture.motion_val[0][pos_b][1];
1719 pos_c = s->block_index[0];
1721 C[0] = s->current_picture.motion_val[0][pos_c][0];
1722 C[1] = s->current_picture.motion_val[0][pos_c][1];
1725 total_valid = a_valid + b_valid + c_valid;
1726 // check if predictor A is out of bounds
1727 if (!s->mb_x && !(n == 1 || n == 3)) {
1730 // check if predictor B is out of bounds
1731 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1732 B[0] = B[1] = C[0] = C[1] = 0;
1734 if (!v->blk_mv_type[xy]) {
1735 if (s->mb_width == 1) {
1739 if (total_valid >= 2) {
1740 px = mid_pred(A[0], B[0], C[0]);
1741 py = mid_pred(A[1], B[1], C[1]);
1742 } else if (total_valid) {
1743 if (a_valid) { px = A[0]; py = A[1]; }
1744 if (b_valid) { px = B[0]; py = B[1]; }
1745 if (c_valid) { px = C[0]; py = C[1]; }
1751 field_a = (A[1] & 4) ? 1 : 0;
1755 field_b = (B[1] & 4) ? 1 : 0;
1759 field_c = (C[1] & 4) ? 1 : 0;
1763 num_oppfield = field_a + field_b + field_c;
1764 num_samefield = total_valid - num_oppfield;
1765 if (total_valid == 3) {
1766 if ((num_samefield == 3) || (num_oppfield == 3)) {
1767 px = mid_pred(A[0], B[0], C[0]);
1768 py = mid_pred(A[1], B[1], C[1]);
1769 } else if (num_samefield >= num_oppfield) {
1770 /* take one MV from same field set depending on priority
1771 the check for B may not be necessary */
1772 px = !field_a ? A[0] : B[0];
1773 py = !field_a ? A[1] : B[1];
1775 px = field_a ? A[0] : B[0];
1776 py = field_a ? A[1] : B[1];
1778 } else if (total_valid == 2) {
1779 if (num_samefield >= num_oppfield) {
1780 if (!field_a && a_valid) {
1783 } else if (!field_b && b_valid) {
1786 } else if (c_valid) {
1791 if (field_a && a_valid) {
1794 } else if (field_b && b_valid) {
1797 } else if (c_valid) {
1802 } else if (total_valid == 1) {
1803 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1804 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1809 /* store MV using signed modulus of MV range defined in 4.11 */
1810 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1811 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1812 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1813 s->current_picture.motion_val[0][xy + 1 ][0] = s->current_picture.motion_val[0][xy][0];
1814 s->current_picture.motion_val[0][xy + 1 ][1] = s->current_picture.motion_val[0][xy][1];
1815 s->current_picture.motion_val[0][xy + wrap ][0] = s->current_picture.motion_val[0][xy][0];
1816 s->current_picture.motion_val[0][xy + wrap ][1] = s->current_picture.motion_val[0][xy][1];
1817 s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
1818 s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
1819 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1820 s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
1821 s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
1822 s->mv[0][n + 1][0] = s->mv[0][n][0];
1823 s->mv[0][n + 1][1] = s->mv[0][n][1];
1827 /** Motion compensation for direct or interpolated blocks in B-frames
1829 static void vc1_interp_mc(VC1Context *v)
1831 MpegEncContext *s = &v->s;
1832 H264ChromaContext *h264chroma = &v->h264chroma;
1833 uint8_t *srcY, *srcU, *srcV;
1834 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1836 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1838 if (!v->field_mode && !v->s.next_picture.f.data[0])
1841 mx = s->mv[1][0][0];
1842 my = s->mv[1][0][1];
1843 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1844 uvmy = (my + ((my & 3) == 3)) >> 1;
1845 if (v->field_mode) {
1846 if (v->cur_field_type != v->ref_field_type[1])
1847 my = my - 2 + 4 * v->cur_field_type;
1848 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1851 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1852 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1854 srcY = s->next_picture.f.data[0];
1855 srcU = s->next_picture.f.data[1];
1856 srcV = s->next_picture.f.data[2];
1858 src_x = s->mb_x * 16 + (mx >> 2);
1859 src_y = s->mb_y * 16 + (my >> 2);
1860 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1861 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1863 if (v->profile != PROFILE_ADVANCED) {
1864 src_x = av_clip( src_x, -16, s->mb_width * 16);
1865 src_y = av_clip( src_y, -16, s->mb_height * 16);
1866 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1867 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1869 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1870 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1871 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1872 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1875 srcY += src_y * s->linesize + src_x;
1876 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1877 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1879 if (v->field_mode && v->ref_field_type[1]) {
1880 srcY += s->current_picture_ptr->f.linesize[0];
1881 srcU += s->current_picture_ptr->f.linesize[1];
1882 srcV += s->current_picture_ptr->f.linesize[2];
1885 /* for grayscale we should not try to read from unknown area */
1886 if (s->flags & CODEC_FLAG_GRAY) {
1887 srcU = s->edge_emu_buffer + 18 * s->linesize;
1888 srcV = s->edge_emu_buffer + 18 * s->linesize;
1891 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1892 || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1893 || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1894 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1896 srcY -= s->mspel * (1 + s->linesize);
1897 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1898 17 + s->mspel * 2, 17 + s->mspel * 2,
1899 src_x - s->mspel, src_y - s->mspel,
1900 s->h_edge_pos, v_edge_pos);
1901 srcY = s->edge_emu_buffer;
1902 s->vdsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1903 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1904 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1905 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1908 /* if we deal with range reduction we need to scale source blocks */
1909 if (v->rangeredfrm) {
1911 uint8_t *src, *src2;
1914 for (j = 0; j < 17 + s->mspel * 2; j++) {
1915 for (i = 0; i < 17 + s->mspel * 2; i++)
1916 src[i] = ((src[i] - 128) >> 1) + 128;
1921 for (j = 0; j < 9; j++) {
1922 for (i = 0; i < 9; i++) {
1923 src[i] = ((src[i] - 128) >> 1) + 128;
1924 src2[i] = ((src2[i] - 128) >> 1) + 128;
1926 src += s->uvlinesize;
1927 src2 += s->uvlinesize;
1930 srcY += s->mspel * (1 + s->linesize);
1933 if (v->field_mode && v->cur_field_type) {
1934 off = s->current_picture_ptr->f.linesize[0];
1935 off_uv = s->current_picture_ptr->f.linesize[1];
1942 dxy = ((my & 3) << 2) | (mx & 3);
1943 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
1944 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1945 srcY += s->linesize * 8;
1946 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
1947 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1949 dxy = (my & 2) | ((mx & 2) >> 1);
1952 s->hdsp.avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1954 s->hdsp.avg_no_rnd_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, 16);
1957 if (s->flags & CODEC_FLAG_GRAY) return;
1958 /* Chroma MC always uses qpel blilinear */
1959 uvmx = (uvmx & 3) << 1;
1960 uvmy = (uvmy & 3) << 1;
1962 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1963 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1965 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1966 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1970 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1974 #if B_FRACTION_DEN==256
1978 return 2 * ((value * n + 255) >> 9);
1979 return (value * n + 128) >> 8;
1982 n -= B_FRACTION_DEN;
1984 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1985 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1989 /** Reconstruct motion vector for B-frame and do motion compensation
1991 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
1992 int direct, int mode)
1995 v->mv_mode2 = v->mv_mode;
1996 v->mv_mode = MV_PMODE_INTENSITY_COMP;
2002 v->mv_mode = v->mv_mode2;
2005 if (mode == BMV_TYPE_INTERPOLATED) {
2009 v->mv_mode = v->mv_mode2;
2013 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2014 v->mv_mode = v->mv_mode2;
2015 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2017 v->mv_mode = v->mv_mode2;
2020 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2021 int direct, int mvtype)
2023 MpegEncContext *s = &v->s;
2024 int xy, wrap, off = 0;
2029 const uint8_t *is_intra = v->mb_type[0];
2033 /* scale MV difference to be quad-pel */
2034 dmv_x[0] <<= 1 - s->quarter_sample;
2035 dmv_y[0] <<= 1 - s->quarter_sample;
2036 dmv_x[1] <<= 1 - s->quarter_sample;
2037 dmv_y[1] <<= 1 - s->quarter_sample;
2039 wrap = s->b8_stride;
2040 xy = s->block_index[0];
2043 s->current_picture.motion_val[0][xy + v->blocks_off][0] =
2044 s->current_picture.motion_val[0][xy + v->blocks_off][1] =
2045 s->current_picture.motion_val[1][xy + v->blocks_off][0] =
2046 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
2049 if (!v->field_mode) {
2050 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2051 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2052 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2053 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2055 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2056 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));
2057 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));
2058 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));
2059 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));
2062 s->current_picture.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2063 s->current_picture.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2064 s->current_picture.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2065 s->current_picture.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2069 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2070 C = s->current_picture.motion_val[0][xy - 2];
2071 A = s->current_picture.motion_val[0][xy - wrap * 2];
2072 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2073 B = s->current_picture.motion_val[0][xy - wrap * 2 + off];
2075 if (!s->mb_x) C[0] = C[1] = 0;
2076 if (!s->first_slice_line) { // predictor A is not out of bounds
2077 if (s->mb_width == 1) {
2081 px = mid_pred(A[0], B[0], C[0]);
2082 py = mid_pred(A[1], B[1], C[1]);
2084 } else if (s->mb_x) { // predictor C is not out of bounds
2090 /* Pullback MV as specified in 8.3.5.3.4 */
2093 if (v->profile < PROFILE_ADVANCED) {
2094 qx = (s->mb_x << 5);
2095 qy = (s->mb_y << 5);
2096 X = (s->mb_width << 5) - 4;
2097 Y = (s->mb_height << 5) - 4;
2098 if (qx + px < -28) px = -28 - qx;
2099 if (qy + py < -28) py = -28 - qy;
2100 if (qx + px > X) px = X - qx;
2101 if (qy + py > Y) py = Y - qy;
2103 qx = (s->mb_x << 6);
2104 qy = (s->mb_y << 6);
2105 X = (s->mb_width << 6) - 4;
2106 Y = (s->mb_height << 6) - 4;
2107 if (qx + px < -60) px = -60 - qx;
2108 if (qy + py < -60) py = -60 - qy;
2109 if (qx + px > X) px = X - qx;
2110 if (qy + py > Y) py = Y - qy;
2113 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2114 if (0 && !s->first_slice_line && s->mb_x) {
2115 if (is_intra[xy - wrap])
2116 sum = FFABS(px) + FFABS(py);
2118 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2120 if (get_bits1(&s->gb)) {
2128 if (is_intra[xy - 2])
2129 sum = FFABS(px) + FFABS(py);
2131 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2133 if (get_bits1(&s->gb)) {
2143 /* store MV using signed modulus of MV range defined in 4.11 */
2144 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2145 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2147 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2148 C = s->current_picture.motion_val[1][xy - 2];
2149 A = s->current_picture.motion_val[1][xy - wrap * 2];
2150 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2151 B = s->current_picture.motion_val[1][xy - wrap * 2 + off];
2155 if (!s->first_slice_line) { // predictor A is not out of bounds
2156 if (s->mb_width == 1) {
2160 px = mid_pred(A[0], B[0], C[0]);
2161 py = mid_pred(A[1], B[1], C[1]);
2163 } else if (s->mb_x) { // predictor C is not out of bounds
2169 /* Pullback MV as specified in 8.3.5.3.4 */
2172 if (v->profile < PROFILE_ADVANCED) {
2173 qx = (s->mb_x << 5);
2174 qy = (s->mb_y << 5);
2175 X = (s->mb_width << 5) - 4;
2176 Y = (s->mb_height << 5) - 4;
2177 if (qx + px < -28) px = -28 - qx;
2178 if (qy + py < -28) py = -28 - qy;
2179 if (qx + px > X) px = X - qx;
2180 if (qy + py > Y) py = Y - qy;
2182 qx = (s->mb_x << 6);
2183 qy = (s->mb_y << 6);
2184 X = (s->mb_width << 6) - 4;
2185 Y = (s->mb_height << 6) - 4;
2186 if (qx + px < -60) px = -60 - qx;
2187 if (qy + py < -60) py = -60 - qy;
2188 if (qx + px > X) px = X - qx;
2189 if (qy + py > Y) py = Y - qy;
2192 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2193 if (0 && !s->first_slice_line && s->mb_x) {
2194 if (is_intra[xy - wrap])
2195 sum = FFABS(px) + FFABS(py);
2197 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2199 if (get_bits1(&s->gb)) {
2207 if (is_intra[xy - 2])
2208 sum = FFABS(px) + FFABS(py);
2210 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2212 if (get_bits1(&s->gb)) {
2222 /* store MV using signed modulus of MV range defined in 4.11 */
2224 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2225 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2227 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2228 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2229 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2230 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2233 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2235 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2236 MpegEncContext *s = &v->s;
2237 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2239 if (v->bmvtype == BMV_TYPE_DIRECT) {
2240 int total_opp, k, f;
2241 if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2242 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2243 v->bfraction, 0, s->quarter_sample);
2244 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2245 v->bfraction, 0, s->quarter_sample);
2246 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2247 v->bfraction, 1, s->quarter_sample);
2248 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2249 v->bfraction, 1, s->quarter_sample);
2251 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2252 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2253 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2254 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2255 f = (total_opp > 2) ? 1 : 0;
2257 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2258 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2261 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2262 for (k = 0; k < 4; k++) {
2263 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2264 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2265 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2266 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2267 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2268 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2272 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2273 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);
2274 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);
2277 if (dir) { // backward
2278 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);
2279 if (n == 3 || mv1) {
2280 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2283 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);
2284 if (n == 3 || mv1) {
2285 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2290 /** Get predicted DC value for I-frames only
2291 * prediction dir: left=0, top=1
2292 * @param s MpegEncContext
2293 * @param overlap flag indicating that overlap filtering is used
2294 * @param pq integer part of picture quantizer
2295 * @param[in] n block index in the current MB
2296 * @param dc_val_ptr Pointer to DC predictor
2297 * @param dir_ptr Prediction direction for use in AC prediction
2299 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2300 int16_t **dc_val_ptr, int *dir_ptr)
2302 int a, b, c, wrap, pred, scale;
2304 static const uint16_t dcpred[32] = {
2305 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2306 114, 102, 93, 85, 79, 73, 68, 64,
2307 60, 57, 54, 51, 49, 47, 45, 43,
2308 41, 39, 38, 37, 35, 34, 33
2311 /* find prediction - wmv3_dc_scale always used here in fact */
2312 if (n < 4) scale = s->y_dc_scale;
2313 else scale = s->c_dc_scale;
2315 wrap = s->block_wrap[n];
2316 dc_val = s->dc_val[0] + s->block_index[n];
2322 b = dc_val[ - 1 - wrap];
2323 a = dc_val[ - wrap];
2325 if (pq < 9 || !overlap) {
2326 /* Set outer values */
2327 if (s->first_slice_line && (n != 2 && n != 3))
2328 b = a = dcpred[scale];
2329 if (s->mb_x == 0 && (n != 1 && n != 3))
2330 b = c = dcpred[scale];
2332 /* Set outer values */
2333 if (s->first_slice_line && (n != 2 && n != 3))
2335 if (s->mb_x == 0 && (n != 1 && n != 3))
2339 if (abs(a - b) <= abs(b - c)) {
2341 *dir_ptr = 1; // left
2344 *dir_ptr = 0; // top
2347 /* update predictor */
2348 *dc_val_ptr = &dc_val[0];
2353 /** Get predicted DC value
2354 * prediction dir: left=0, top=1
2355 * @param s MpegEncContext
2356 * @param overlap flag indicating that overlap filtering is used
2357 * @param pq integer part of picture quantizer
2358 * @param[in] n block index in the current MB
2359 * @param a_avail flag indicating top block availability
2360 * @param c_avail flag indicating left block availability
2361 * @param dc_val_ptr Pointer to DC predictor
2362 * @param dir_ptr Prediction direction for use in AC prediction
2364 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2365 int a_avail, int c_avail,
2366 int16_t **dc_val_ptr, int *dir_ptr)
2368 int a, b, c, wrap, pred;
2370 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2374 wrap = s->block_wrap[n];
2375 dc_val = s->dc_val[0] + s->block_index[n];
2381 b = dc_val[ - 1 - wrap];
2382 a = dc_val[ - wrap];
2383 /* scale predictors if needed */
2384 q1 = s->current_picture.qscale_table[mb_pos];
2385 dqscale_index = s->y_dc_scale_table[q1] - 1;
2386 if (dqscale_index < 0)
2388 if (c_avail && (n != 1 && n != 3)) {
2389 q2 = s->current_picture.qscale_table[mb_pos - 1];
2391 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2393 if (a_avail && (n != 2 && n != 3)) {
2394 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2396 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2398 if (a_avail && c_avail && (n != 3)) {
2403 off -= s->mb_stride;
2404 q2 = s->current_picture.qscale_table[off];
2406 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2409 if (a_avail && c_avail) {
2410 if (abs(a - b) <= abs(b - c)) {
2412 *dir_ptr = 1; // left
2415 *dir_ptr = 0; // top
2417 } else if (a_avail) {
2419 *dir_ptr = 0; // top
2420 } else if (c_avail) {
2422 *dir_ptr = 1; // left
2425 *dir_ptr = 1; // left
2428 /* update predictor */
2429 *dc_val_ptr = &dc_val[0];
2433 /** @} */ // Block group
2436 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2437 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2441 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2442 uint8_t **coded_block_ptr)
2444 int xy, wrap, pred, a, b, c;
2446 xy = s->block_index[n];
2447 wrap = s->b8_stride;
2452 a = s->coded_block[xy - 1 ];
2453 b = s->coded_block[xy - 1 - wrap];
2454 c = s->coded_block[xy - wrap];
2463 *coded_block_ptr = &s->coded_block[xy];
2469 * Decode one AC coefficient
2470 * @param v The VC1 context
2471 * @param last Last coefficient
2472 * @param skip How much zero coefficients to skip
2473 * @param value Decoded AC coefficient value
2474 * @param codingset set of VLC to decode data
2477 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2478 int *value, int codingset)
2480 GetBitContext *gb = &v->s.gb;
2481 int index, escape, run = 0, level = 0, lst = 0;
2483 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2484 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2485 run = vc1_index_decode_table[codingset][index][0];
2486 level = vc1_index_decode_table[codingset][index][1];
2487 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2491 escape = decode210(gb);
2493 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2494 run = vc1_index_decode_table[codingset][index][0];
2495 level = vc1_index_decode_table[codingset][index][1];
2496 lst = index >= vc1_last_decode_table[codingset];
2499 level += vc1_last_delta_level_table[codingset][run];
2501 level += vc1_delta_level_table[codingset][run];
2504 run += vc1_last_delta_run_table[codingset][level] + 1;
2506 run += vc1_delta_run_table[codingset][level] + 1;
2512 lst = get_bits1(gb);
2513 if (v->s.esc3_level_length == 0) {
2514 if (v->pq < 8 || v->dquantfrm) { // table 59
2515 v->s.esc3_level_length = get_bits(gb, 3);
2516 if (!v->s.esc3_level_length)
2517 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2518 } else { // table 60
2519 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2521 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2523 run = get_bits(gb, v->s.esc3_run_length);
2524 sign = get_bits1(gb);
2525 level = get_bits(gb, v->s.esc3_level_length);
2536 /** Decode intra block in intra frames - should be faster than decode_intra_block
2537 * @param v VC1Context
2538 * @param block block to decode
2539 * @param[in] n subblock index
2540 * @param coded are AC coeffs present or not
2541 * @param codingset set of VLC to decode data
2543 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
2544 int coded, int codingset)
2546 GetBitContext *gb = &v->s.gb;
2547 MpegEncContext *s = &v->s;
2548 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2551 int16_t *ac_val, *ac_val2;
2554 /* Get DC differential */
2556 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2558 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2561 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2565 if (dcdiff == 119 /* ESC index value */) {
2566 /* TODO: Optimize */
2567 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2568 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2569 else dcdiff = get_bits(gb, 8);
2572 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2573 else if (v->pq == 2)
2574 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2581 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2584 /* Store the quantized DC coeff, used for prediction */
2586 block[0] = dcdiff * s->y_dc_scale;
2588 block[0] = dcdiff * s->c_dc_scale;
2599 int last = 0, skip, value;
2600 const uint8_t *zz_table;
2604 scale = v->pq * 2 + v->halfpq;
2608 zz_table = v->zz_8x8[2];
2610 zz_table = v->zz_8x8[3];
2612 zz_table = v->zz_8x8[1];
2614 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2616 if (dc_pred_dir) // left
2619 ac_val -= 16 * s->block_wrap[n];
2622 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2626 block[zz_table[i++]] = value;
2629 /* apply AC prediction if needed */
2631 if (dc_pred_dir) { // left
2632 for (k = 1; k < 8; k++)
2633 block[k << v->left_blk_sh] += ac_val[k];
2635 for (k = 1; k < 8; k++)
2636 block[k << v->top_blk_sh] += ac_val[k + 8];
2639 /* save AC coeffs for further prediction */
2640 for (k = 1; k < 8; k++) {
2641 ac_val2[k] = block[k << v->left_blk_sh];
2642 ac_val2[k + 8] = block[k << v->top_blk_sh];
2645 /* scale AC coeffs */
2646 for (k = 1; k < 64; k++)
2650 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2653 if (s->ac_pred) i = 63;
2659 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2663 scale = v->pq * 2 + v->halfpq;
2664 memset(ac_val2, 0, 16 * 2);
2665 if (dc_pred_dir) { // left
2668 memcpy(ac_val2, ac_val, 8 * 2);
2670 ac_val -= 16 * s->block_wrap[n];
2672 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2675 /* apply AC prediction if needed */
2677 if (dc_pred_dir) { //left
2678 for (k = 1; k < 8; k++) {
2679 block[k << v->left_blk_sh] = ac_val[k] * scale;
2680 if (!v->pquantizer && block[k << v->left_blk_sh])
2681 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2684 for (k = 1; k < 8; k++) {
2685 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2686 if (!v->pquantizer && block[k << v->top_blk_sh])
2687 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2693 s->block_last_index[n] = i;
2698 /** Decode intra block in intra frames - should be faster than decode_intra_block
2699 * @param v VC1Context
2700 * @param block block to decode
2701 * @param[in] n subblock number
2702 * @param coded are AC coeffs present or not
2703 * @param codingset set of VLC to decode data
2704 * @param mquant quantizer value for this macroblock
2706 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
2707 int coded, int codingset, int mquant)
2709 GetBitContext *gb = &v->s.gb;
2710 MpegEncContext *s = &v->s;
2711 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2714 int16_t *ac_val, *ac_val2;
2716 int a_avail = v->a_avail, c_avail = v->c_avail;
2717 int use_pred = s->ac_pred;
2720 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2722 /* Get DC differential */
2724 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2726 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2729 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2733 if (dcdiff == 119 /* ESC index value */) {
2734 /* TODO: Optimize */
2735 if (mquant == 1) dcdiff = get_bits(gb, 10);
2736 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2737 else dcdiff = get_bits(gb, 8);
2740 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2741 else if (mquant == 2)
2742 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2749 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2752 /* Store the quantized DC coeff, used for prediction */
2754 block[0] = dcdiff * s->y_dc_scale;
2756 block[0] = dcdiff * s->c_dc_scale;
2762 /* check if AC is needed at all */
2763 if (!a_avail && !c_avail)
2765 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2768 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2770 if (dc_pred_dir) // left
2773 ac_val -= 16 * s->block_wrap[n];
2775 q1 = s->current_picture.qscale_table[mb_pos];
2776 if ( dc_pred_dir && c_avail && mb_pos)
2777 q2 = s->current_picture.qscale_table[mb_pos - 1];
2778 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2779 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2780 if ( dc_pred_dir && n == 1)
2782 if (!dc_pred_dir && n == 2)
2788 int last = 0, skip, value;
2789 const uint8_t *zz_table;
2793 if (!use_pred && v->fcm == ILACE_FRAME) {
2794 zz_table = v->zzi_8x8;
2796 if (!dc_pred_dir) // top
2797 zz_table = v->zz_8x8[2];
2799 zz_table = v->zz_8x8[3];
2802 if (v->fcm != ILACE_FRAME)
2803 zz_table = v->zz_8x8[1];
2805 zz_table = v->zzi_8x8;
2809 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2813 block[zz_table[i++]] = value;
2816 /* apply AC prediction if needed */
2818 /* scale predictors if needed*/
2819 if (q2 && q1 != q2) {
2820 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2821 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2824 return AVERROR_INVALIDDATA;
2825 if (dc_pred_dir) { // left
2826 for (k = 1; k < 8; k++)
2827 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2829 for (k = 1; k < 8; k++)
2830 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2833 if (dc_pred_dir) { //left
2834 for (k = 1; k < 8; k++)
2835 block[k << v->left_blk_sh] += ac_val[k];
2837 for (k = 1; k < 8; k++)
2838 block[k << v->top_blk_sh] += ac_val[k + 8];
2842 /* save AC coeffs for further prediction */
2843 for (k = 1; k < 8; k++) {
2844 ac_val2[k ] = block[k << v->left_blk_sh];
2845 ac_val2[k + 8] = block[k << v->top_blk_sh];
2848 /* scale AC coeffs */
2849 for (k = 1; k < 64; k++)
2853 block[k] += (block[k] < 0) ? -mquant : mquant;
2856 if (use_pred) i = 63;
2857 } else { // no AC coeffs
2860 memset(ac_val2, 0, 16 * 2);
2861 if (dc_pred_dir) { // left
2863 memcpy(ac_val2, ac_val, 8 * 2);
2864 if (q2 && q1 != q2) {
2865 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2866 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2868 return AVERROR_INVALIDDATA;
2869 for (k = 1; k < 8; k++)
2870 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2875 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2876 if (q2 && q1 != q2) {
2877 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2878 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2880 return AVERROR_INVALIDDATA;
2881 for (k = 1; k < 8; k++)
2882 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2887 /* apply AC prediction if needed */
2889 if (dc_pred_dir) { // left
2890 for (k = 1; k < 8; k++) {
2891 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2892 if (!v->pquantizer && block[k << v->left_blk_sh])
2893 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2896 for (k = 1; k < 8; k++) {
2897 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2898 if (!v->pquantizer && block[k << v->top_blk_sh])
2899 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2905 s->block_last_index[n] = i;
2910 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2911 * @param v VC1Context
2912 * @param block block to decode
2913 * @param[in] n subblock index
2914 * @param coded are AC coeffs present or not
2915 * @param mquant block quantizer
2916 * @param codingset set of VLC to decode data
2918 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
2919 int coded, int mquant, int codingset)
2921 GetBitContext *gb = &v->s.gb;
2922 MpegEncContext *s = &v->s;
2923 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2926 int16_t *ac_val, *ac_val2;
2928 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2929 int a_avail = v->a_avail, c_avail = v->c_avail;
2930 int use_pred = s->ac_pred;
2934 s->dsp.clear_block(block);
2936 /* XXX: Guard against dumb values of mquant */
2937 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2939 /* Set DC scale - y and c use the same */
2940 s->y_dc_scale = s->y_dc_scale_table[mquant];
2941 s->c_dc_scale = s->c_dc_scale_table[mquant];
2943 /* Get DC differential */
2945 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2947 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2950 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2954 if (dcdiff == 119 /* ESC index value */) {
2955 /* TODO: Optimize */
2956 if (mquant == 1) dcdiff = get_bits(gb, 10);
2957 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2958 else dcdiff = get_bits(gb, 8);
2961 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2962 else if (mquant == 2)
2963 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2970 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2973 /* Store the quantized DC coeff, used for prediction */
2976 block[0] = dcdiff * s->y_dc_scale;
2978 block[0] = dcdiff * s->c_dc_scale;
2984 /* check if AC is needed at all and adjust direction if needed */
2985 if (!a_avail) dc_pred_dir = 1;
2986 if (!c_avail) dc_pred_dir = 0;
2987 if (!a_avail && !c_avail) use_pred = 0;
2988 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2991 scale = mquant * 2 + v->halfpq;
2993 if (dc_pred_dir) //left
2996 ac_val -= 16 * s->block_wrap[n];
2998 q1 = s->current_picture.qscale_table[mb_pos];
2999 if (dc_pred_dir && c_avail && mb_pos)
3000 q2 = s->current_picture.qscale_table[mb_pos - 1];
3001 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3002 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3003 if ( dc_pred_dir && n == 1)
3005 if (!dc_pred_dir && n == 2)
3007 if (n == 3) q2 = q1;
3010 int last = 0, skip, value;
3014 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3018 if (v->fcm == PROGRESSIVE)
3019 block[v->zz_8x8[0][i++]] = value;
3021 if (use_pred && (v->fcm == ILACE_FRAME)) {
3022 if (!dc_pred_dir) // top
3023 block[v->zz_8x8[2][i++]] = value;
3025 block[v->zz_8x8[3][i++]] = value;
3027 block[v->zzi_8x8[i++]] = value;
3032 /* apply AC prediction if needed */
3034 /* scale predictors if needed*/
3035 if (q2 && q1 != q2) {
3036 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3037 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3040 return AVERROR_INVALIDDATA;
3041 if (dc_pred_dir) { // left
3042 for (k = 1; k < 8; k++)
3043 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3045 for (k = 1; k < 8; k++)
3046 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3049 if (dc_pred_dir) { // left
3050 for (k = 1; k < 8; k++)
3051 block[k << v->left_blk_sh] += ac_val[k];
3053 for (k = 1; k < 8; k++)
3054 block[k << v->top_blk_sh] += ac_val[k + 8];
3058 /* save AC coeffs for further prediction */
3059 for (k = 1; k < 8; k++) {
3060 ac_val2[k ] = block[k << v->left_blk_sh];
3061 ac_val2[k + 8] = block[k << v->top_blk_sh];
3064 /* scale AC coeffs */
3065 for (k = 1; k < 64; k++)
3069 block[k] += (block[k] < 0) ? -mquant : mquant;
3072 if (use_pred) i = 63;
3073 } else { // no AC coeffs
3076 memset(ac_val2, 0, 16 * 2);
3077 if (dc_pred_dir) { // left
3079 memcpy(ac_val2, ac_val, 8 * 2);
3080 if (q2 && q1 != q2) {
3081 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3082 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3084 return AVERROR_INVALIDDATA;
3085 for (k = 1; k < 8; k++)
3086 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3091 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3092 if (q2 && q1 != q2) {
3093 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3094 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3096 return AVERROR_INVALIDDATA;
3097 for (k = 1; k < 8; k++)
3098 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3103 /* apply AC prediction if needed */
3105 if (dc_pred_dir) { // left
3106 for (k = 1; k < 8; k++) {
3107 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3108 if (!v->pquantizer && block[k << v->left_blk_sh])
3109 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3112 for (k = 1; k < 8; k++) {
3113 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3114 if (!v->pquantizer && block[k << v->top_blk_sh])
3115 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3121 s->block_last_index[n] = i;
3128 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
3129 int mquant, int ttmb, int first_block,
3130 uint8_t *dst, int linesize, int skip_block,
3133 MpegEncContext *s = &v->s;
3134 GetBitContext *gb = &s->gb;
3137 int scale, off, idx, last, skip, value;
3138 int ttblk = ttmb & 7;
3141 s->dsp.clear_block(block);
3144 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)];
3146 if (ttblk == TT_4X4) {
3147 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3149 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3150 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3151 || (!v->res_rtm_flag && !first_block))) {
3152 subblkpat = decode012(gb);
3154 subblkpat ^= 3; // swap decoded pattern bits
3155 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3157 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3160 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3162 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3163 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3164 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3167 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3168 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3177 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3182 idx = v->zz_8x8[0][i++];
3184 idx = v->zzi_8x8[i++];
3185 block[idx] = value * scale;
3187 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3191 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3193 v->vc1dsp.vc1_inv_trans_8x8(block);
3194 s->dsp.add_pixels_clamped(block, dst, linesize);
3199 pat = ~subblkpat & 0xF;
3200 for (j = 0; j < 4; j++) {
3201 last = subblkpat & (1 << (3 - j));
3203 off = (j & 1) * 4 + (j & 2) * 16;
3205 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3210 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3212 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3213 block[idx + off] = value * scale;
3215 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3217 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3219 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3221 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3226 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3227 for (j = 0; j < 2; j++) {
3228 last = subblkpat & (1 << (1 - j));
3232 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3237 idx = v->zz_8x4[i++] + off;
3239 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3240 block[idx] = value * scale;
3242 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3244 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3246 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3248 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3253 pat = ~(subblkpat * 5) & 0xF;
3254 for (j = 0; j < 2; j++) {
3255 last = subblkpat & (1 << (1 - j));
3259 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3264 idx = v->zz_4x8[i++] + off;
3266 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3267 block[idx] = value * scale;
3269 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3271 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3273 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3275 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3281 *ttmb_out |= ttblk << (n * 4);
3285 /** @} */ // Macroblock group
3287 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3288 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3290 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3292 MpegEncContext *s = &v->s;
3293 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3294 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3295 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3296 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3297 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3300 if (block_num > 3) {
3301 dst = s->dest[block_num - 3];
3303 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3305 if (s->mb_y != s->end_mb_y || block_num < 2) {
3309 if (block_num > 3) {
3310 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3311 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3312 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3313 mv_stride = s->mb_stride;
3315 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3316 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3317 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3318 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3319 mv_stride = s->b8_stride;
3320 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3323 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3324 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3325 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3327 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3329 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3332 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3334 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3339 dst -= 4 * linesize;
3340 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3341 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3342 idx = (block_cbp | (block_cbp >> 2)) & 3;
3344 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3347 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3349 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3354 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3356 MpegEncContext *s = &v->s;
3357 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3358 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3359 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3360 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3361 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3364 if (block_num > 3) {
3365 dst = s->dest[block_num - 3] - 8 * linesize;
3367 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3370 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3373 if (block_num > 3) {
3374 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3375 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3376 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3378 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3379 : (mb_cbp >> ((block_num + 1) * 4));
3380 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3381 : (mb_is_intra >> ((block_num + 1) * 4));
3382 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3384 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3385 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3387 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3389 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3392 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3394 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3400 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3401 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3402 idx = (block_cbp | (block_cbp >> 1)) & 5;
3404 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3407 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3409 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3414 static void vc1_apply_p_loop_filter(VC1Context *v)
3416 MpegEncContext *s = &v->s;
3419 for (i = 0; i < 6; i++) {
3420 vc1_apply_p_v_loop_filter(v, i);
3423 /* V always precedes H, therefore we run H one MB before V;
3424 * at the end of a row, we catch up to complete the row */
3426 for (i = 0; i < 6; i++) {
3427 vc1_apply_p_h_loop_filter(v, i);
3429 if (s->mb_x == s->mb_width - 1) {
3431 ff_update_block_index(s);
3432 for (i = 0; i < 6; i++) {
3433 vc1_apply_p_h_loop_filter(v, i);
3439 /** Decode one P-frame MB
3441 static int vc1_decode_p_mb(VC1Context *v)
3443 MpegEncContext *s = &v->s;
3444 GetBitContext *gb = &s->gb;
3446 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3447 int cbp; /* cbp decoding stuff */
3448 int mqdiff, mquant; /* MB quantization */
3449 int ttmb = v->ttfrm; /* MB Transform type */
3451 int mb_has_coeffs = 1; /* last_flag */
3452 int dmv_x, dmv_y; /* Differential MV components */
3453 int index, index1; /* LUT indexes */
3454 int val, sign; /* temp values */
3455 int first_block = 1;
3457 int skipped, fourmv;
3458 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3460 mquant = v->pq; /* lossy initialization */
3462 if (v->mv_type_is_raw)
3463 fourmv = get_bits1(gb);
3465 fourmv = v->mv_type_mb_plane[mb_pos];
3467 skipped = get_bits1(gb);
3469 skipped = v->s.mbskip_table[mb_pos];
3471 if (!fourmv) { /* 1MV mode */
3473 GET_MVDATA(dmv_x, dmv_y);
3476 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3477 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3479 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3480 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3482 /* FIXME Set DC val for inter block ? */
3483 if (s->mb_intra && !mb_has_coeffs) {
3485 s->ac_pred = get_bits1(gb);
3487 } else if (mb_has_coeffs) {
3489 s->ac_pred = get_bits1(gb);
3490 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3496 s->current_picture.qscale_table[mb_pos] = mquant;
3498 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3499 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3500 VC1_TTMB_VLC_BITS, 2);
3501 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3503 for (i = 0; i < 6; i++) {
3504 s->dc_val[0][s->block_index[i]] = 0;
3506 val = ((cbp >> (5 - i)) & 1);
3507 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3508 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3510 /* check if prediction blocks A and C are available */
3511 v->a_avail = v->c_avail = 0;
3512 if (i == 2 || i == 3 || !s->first_slice_line)
3513 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3514 if (i == 1 || i == 3 || s->mb_x)
3515 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3517 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3518 (i & 4) ? v->codingset2 : v->codingset);
3519 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3521 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3523 for (j = 0; j < 64; j++)
3524 s->block[i][j] <<= 1;
3525 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3526 if (v->pq >= 9 && v->overlap) {
3528 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3530 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3532 block_cbp |= 0xF << (i << 2);
3533 block_intra |= 1 << i;
3535 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3536 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3537 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3538 block_cbp |= pat << (i << 2);
3539 if (!v->ttmbf && ttmb < 8)
3546 for (i = 0; i < 6; i++) {
3547 v->mb_type[0][s->block_index[i]] = 0;
3548 s->dc_val[0][s->block_index[i]] = 0;
3550 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3551 s->current_picture.qscale_table[mb_pos] = 0;
3552 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3555 } else { // 4MV mode
3556 if (!skipped /* unskipped MB */) {
3557 int intra_count = 0, coded_inter = 0;
3558 int is_intra[6], is_coded[6];
3560 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3561 for (i = 0; i < 6; i++) {
3562 val = ((cbp >> (5 - i)) & 1);
3563 s->dc_val[0][s->block_index[i]] = 0;
3570 GET_MVDATA(dmv_x, dmv_y);
3572 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3574 vc1_mc_4mv_luma(v, i, 0);
3575 intra_count += s->mb_intra;
3576 is_intra[i] = s->mb_intra;
3577 is_coded[i] = mb_has_coeffs;
3580 is_intra[i] = (intra_count >= 3);
3584 vc1_mc_4mv_chroma(v, 0);
3585 v->mb_type[0][s->block_index[i]] = is_intra[i];
3587 coded_inter = !is_intra[i] & is_coded[i];
3589 // if there are no coded blocks then don't do anything more
3591 if (!intra_count && !coded_inter)
3594 s->current_picture.qscale_table[mb_pos] = mquant;
3595 /* test if block is intra and has pred */
3598 for (i = 0; i < 6; i++)
3600 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3601 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3607 s->ac_pred = get_bits1(gb);
3611 if (!v->ttmbf && coded_inter)
3612 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3613 for (i = 0; i < 6; i++) {
3615 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3616 s->mb_intra = is_intra[i];
3618 /* check if prediction blocks A and C are available */
3619 v->a_avail = v->c_avail = 0;
3620 if (i == 2 || i == 3 || !s->first_slice_line)
3621 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3622 if (i == 1 || i == 3 || s->mb_x)
3623 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3625 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3626 (i & 4) ? v->codingset2 : v->codingset);
3627 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3629 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3631 for (j = 0; j < 64; j++)
3632 s->block[i][j] <<= 1;
3633 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3634 (i & 4) ? s->uvlinesize : s->linesize);
3635 if (v->pq >= 9 && v->overlap) {
3637 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3639 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3641 block_cbp |= 0xF << (i << 2);
3642 block_intra |= 1 << i;
3643 } else if (is_coded[i]) {
3644 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3645 first_block, s->dest[dst_idx] + off,
3646 (i & 4) ? s->uvlinesize : s->linesize,
3647 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3649 block_cbp |= pat << (i << 2);
3650 if (!v->ttmbf && ttmb < 8)
3655 } else { // skipped MB
3657 s->current_picture.qscale_table[mb_pos] = 0;
3658 for (i = 0; i < 6; i++) {
3659 v->mb_type[0][s->block_index[i]] = 0;
3660 s->dc_val[0][s->block_index[i]] = 0;
3662 for (i = 0; i < 4; i++) {
3663 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3664 vc1_mc_4mv_luma(v, i, 0);
3666 vc1_mc_4mv_chroma(v, 0);
3667 s->current_picture.qscale_table[mb_pos] = 0;
3671 v->cbp[s->mb_x] = block_cbp;
3672 v->ttblk[s->mb_x] = block_tt;
3673 v->is_intra[s->mb_x] = block_intra;
3678 /* Decode one macroblock in an interlaced frame p picture */
3680 static int vc1_decode_p_mb_intfr(VC1Context *v)
3682 MpegEncContext *s = &v->s;
3683 GetBitContext *gb = &s->gb;
3685 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3686 int cbp = 0; /* cbp decoding stuff */
3687 int mqdiff, mquant; /* MB quantization */
3688 int ttmb = v->ttfrm; /* MB Transform type */
3690 int mb_has_coeffs = 1; /* last_flag */
3691 int dmv_x, dmv_y; /* Differential MV components */
3692 int val; /* temp value */
3693 int first_block = 1;
3695 int skipped, fourmv = 0, twomv = 0;
3696 int block_cbp = 0, pat, block_tt = 0;
3697 int idx_mbmode = 0, mvbp;
3698 int stride_y, fieldtx;
3700 mquant = v->pq; /* Loosy initialization */
3703 skipped = get_bits1(gb);
3705 skipped = v->s.mbskip_table[mb_pos];
3707 if (v->fourmvswitch)
3708 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3710 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3711 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3712 /* store the motion vector type in a flag (useful later) */
3713 case MV_PMODE_INTFR_4MV:
3715 v->blk_mv_type[s->block_index[0]] = 0;
3716 v->blk_mv_type[s->block_index[1]] = 0;
3717 v->blk_mv_type[s->block_index[2]] = 0;
3718 v->blk_mv_type[s->block_index[3]] = 0;
3720 case MV_PMODE_INTFR_4MV_FIELD:
3722 v->blk_mv_type[s->block_index[0]] = 1;
3723 v->blk_mv_type[s->block_index[1]] = 1;
3724 v->blk_mv_type[s->block_index[2]] = 1;
3725 v->blk_mv_type[s->block_index[3]] = 1;
3727 case MV_PMODE_INTFR_2MV_FIELD:
3729 v->blk_mv_type[s->block_index[0]] = 1;
3730 v->blk_mv_type[s->block_index[1]] = 1;
3731 v->blk_mv_type[s->block_index[2]] = 1;
3732 v->blk_mv_type[s->block_index[3]] = 1;
3734 case MV_PMODE_INTFR_1MV:
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;
3741 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3742 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3743 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3744 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3745 s->mb_intra = v->is_intra[s->mb_x] = 1;
3746 for (i = 0; i < 6; i++)
3747 v->mb_type[0][s->block_index[i]] = 1;
3748 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3749 mb_has_coeffs = get_bits1(gb);
3751 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3752 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3754 s->current_picture.qscale_table[mb_pos] = mquant;
3755 /* Set DC scale - y and c use the same (not sure if necessary here) */
3756 s->y_dc_scale = s->y_dc_scale_table[mquant];
3757 s->c_dc_scale = s->c_dc_scale_table[mquant];
3759 for (i = 0; i < 6; i++) {
3760 s->dc_val[0][s->block_index[i]] = 0;
3762 val = ((cbp >> (5 - i)) & 1);
3763 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3764 v->a_avail = v->c_avail = 0;
3765 if (i == 2 || i == 3 || !s->first_slice_line)
3766 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3767 if (i == 1 || i == 3 || s->mb_x)
3768 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3770 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3771 (i & 4) ? v->codingset2 : v->codingset);
3772 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3773 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3775 stride_y = s->linesize << fieldtx;
3776 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3778 stride_y = s->uvlinesize;
3781 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3785 } else { // inter MB
3786 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3788 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3789 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3790 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3792 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3793 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3794 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3797 s->mb_intra = v->is_intra[s->mb_x] = 0;
3798 for (i = 0; i < 6; i++)
3799 v->mb_type[0][s->block_index[i]] = 0;
3800 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3801 /* for all motion vector read MVDATA and motion compensate each block */
3805 for (i = 0; i < 6; i++) {
3808 val = ((mvbp >> (3 - i)) & 1);
3810 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3812 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3813 vc1_mc_4mv_luma(v, i, 0);
3814 } else if (i == 4) {
3815 vc1_mc_4mv_chroma4(v);
3822 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3824 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3825 vc1_mc_4mv_luma(v, 0, 0);
3826 vc1_mc_4mv_luma(v, 1, 0);
3829 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3831 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3832 vc1_mc_4mv_luma(v, 2, 0);
3833 vc1_mc_4mv_luma(v, 3, 0);
3834 vc1_mc_4mv_chroma4(v);
3836 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3839 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3841 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3845 GET_MQUANT(); // p. 227
3846 s->current_picture.qscale_table[mb_pos] = mquant;
3847 if (!v->ttmbf && cbp)
3848 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3849 for (i = 0; i < 6; i++) {
3850 s->dc_val[0][s->block_index[i]] = 0;
3852 val = ((cbp >> (5 - i)) & 1);
3854 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3856 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3858 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3859 first_block, s->dest[dst_idx] + off,
3860 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3861 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3862 block_cbp |= pat << (i << 2);
3863 if (!v->ttmbf && ttmb < 8)
3870 s->mb_intra = v->is_intra[s->mb_x] = 0;
3871 for (i = 0; i < 6; i++) {
3872 v->mb_type[0][s->block_index[i]] = 0;
3873 s->dc_val[0][s->block_index[i]] = 0;
3875 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3876 s->current_picture.qscale_table[mb_pos] = 0;
3877 v->blk_mv_type[s->block_index[0]] = 0;
3878 v->blk_mv_type[s->block_index[1]] = 0;
3879 v->blk_mv_type[s->block_index[2]] = 0;
3880 v->blk_mv_type[s->block_index[3]] = 0;
3881 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3884 if (s->mb_x == s->mb_width - 1)
3885 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3889 static int vc1_decode_p_mb_intfi(VC1Context *v)
3891 MpegEncContext *s = &v->s;
3892 GetBitContext *gb = &s->gb;
3894 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3895 int cbp = 0; /* cbp decoding stuff */
3896 int mqdiff, mquant; /* MB quantization */
3897 int ttmb = v->ttfrm; /* MB Transform type */
3899 int mb_has_coeffs = 1; /* last_flag */
3900 int dmv_x, dmv_y; /* Differential MV components */
3901 int val; /* temp values */
3902 int first_block = 1;
3905 int block_cbp = 0, pat, block_tt = 0;
3908 mquant = v->pq; /* Loosy initialization */
3910 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3911 if (idx_mbmode <= 1) { // intra MB
3912 s->mb_intra = v->is_intra[s->mb_x] = 1;
3913 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3914 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3915 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3917 s->current_picture.qscale_table[mb_pos] = mquant;
3918 /* Set DC scale - y and c use the same (not sure if necessary here) */
3919 s->y_dc_scale = s->y_dc_scale_table[mquant];
3920 s->c_dc_scale = s->c_dc_scale_table[mquant];
3921 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3922 mb_has_coeffs = idx_mbmode & 1;
3924 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3926 for (i = 0; i < 6; i++) {
3927 s->dc_val[0][s->block_index[i]] = 0;
3928 v->mb_type[0][s->block_index[i]] = 1;
3930 val = ((cbp >> (5 - i)) & 1);
3931 v->a_avail = v->c_avail = 0;
3932 if (i == 2 || i == 3 || !s->first_slice_line)
3933 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3934 if (i == 1 || i == 3 || s->mb_x)
3935 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3937 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3938 (i & 4) ? v->codingset2 : v->codingset);
3939 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3941 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3942 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3943 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
3944 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
3945 // TODO: loop filter
3948 s->mb_intra = v->is_intra[s->mb_x] = 0;
3949 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3950 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3951 if (idx_mbmode <= 5) { // 1-MV
3952 dmv_x = dmv_y = pred_flag = 0;
3953 if (idx_mbmode & 1) {
3954 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3956 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3958 mb_has_coeffs = !(idx_mbmode & 2);
3960 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3961 for (i = 0; i < 6; i++) {
3963 dmv_x = dmv_y = pred_flag = 0;
3964 val = ((v->fourmvbp >> (3 - i)) & 1);
3966 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3968 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3969 vc1_mc_4mv_luma(v, i, 0);
3971 vc1_mc_4mv_chroma(v, 0);
3973 mb_has_coeffs = idx_mbmode & 1;
3976 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3980 s->current_picture.qscale_table[mb_pos] = mquant;
3981 if (!v->ttmbf && cbp) {
3982 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3985 for (i = 0; i < 6; i++) {
3986 s->dc_val[0][s->block_index[i]] = 0;
3988 val = ((cbp >> (5 - i)) & 1);
3989 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
3990 if (v->cur_field_type)
3991 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
3993 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3994 first_block, s->dest[dst_idx] + off,
3995 (i & 4) ? s->uvlinesize : s->linesize,
3996 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3998 block_cbp |= pat << (i << 2);
3999 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4004 if (s->mb_x == s->mb_width - 1)
4005 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4009 /** Decode one B-frame MB (in Main profile)
4011 static void vc1_decode_b_mb(VC1Context *v)
4013 MpegEncContext *s = &v->s;
4014 GetBitContext *gb = &s->gb;
4016 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4017 int cbp = 0; /* cbp decoding stuff */
4018 int mqdiff, mquant; /* MB quantization */
4019 int ttmb = v->ttfrm; /* MB Transform type */
4020 int mb_has_coeffs = 0; /* last_flag */
4021 int index, index1; /* LUT indexes */
4022 int val, sign; /* temp values */
4023 int first_block = 1;
4025 int skipped, direct;
4026 int dmv_x[2], dmv_y[2];
4027 int bmvtype = BMV_TYPE_BACKWARD;
4029 mquant = v->pq; /* lossy initialization */
4033 direct = get_bits1(gb);
4035 direct = v->direct_mb_plane[mb_pos];
4037 skipped = get_bits1(gb);
4039 skipped = v->s.mbskip_table[mb_pos];
4041 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4042 for (i = 0; i < 6; i++) {
4043 v->mb_type[0][s->block_index[i]] = 0;
4044 s->dc_val[0][s->block_index[i]] = 0;
4046 s->current_picture.qscale_table[mb_pos] = 0;
4050 GET_MVDATA(dmv_x[0], dmv_y[0]);
4051 dmv_x[1] = dmv_x[0];
4052 dmv_y[1] = dmv_y[0];
4054 if (skipped || !s->mb_intra) {
4055 bmvtype = decode012(gb);
4058 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4061 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4064 bmvtype = BMV_TYPE_INTERPOLATED;
4065 dmv_x[0] = dmv_y[0] = 0;
4069 for (i = 0; i < 6; i++)
4070 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4074 bmvtype = BMV_TYPE_INTERPOLATED;
4075 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4076 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4080 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4083 s->current_picture.qscale_table[mb_pos] = mquant;
4085 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4086 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4087 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4088 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4090 if (!mb_has_coeffs && !s->mb_intra) {
4091 /* no coded blocks - effectively skipped */
4092 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4093 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4096 if (s->mb_intra && !mb_has_coeffs) {
4098 s->current_picture.qscale_table[mb_pos] = mquant;
4099 s->ac_pred = get_bits1(gb);
4101 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4103 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4104 GET_MVDATA(dmv_x[0], dmv_y[0]);
4105 if (!mb_has_coeffs) {
4106 /* interpolated skipped block */
4107 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4108 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4112 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4114 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4117 s->ac_pred = get_bits1(gb);
4118 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4120 s->current_picture.qscale_table[mb_pos] = mquant;
4121 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4122 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4126 for (i = 0; i < 6; i++) {
4127 s->dc_val[0][s->block_index[i]] = 0;
4129 val = ((cbp >> (5 - i)) & 1);
4130 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4131 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4133 /* check if prediction blocks A and C are available */
4134 v->a_avail = v->c_avail = 0;
4135 if (i == 2 || i == 3 || !s->first_slice_line)
4136 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4137 if (i == 1 || i == 3 || s->mb_x)
4138 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4140 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4141 (i & 4) ? v->codingset2 : v->codingset);
4142 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4144 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4146 for (j = 0; j < 64; j++)
4147 s->block[i][j] <<= 1;
4148 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4150 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4151 first_block, s->dest[dst_idx] + off,
4152 (i & 4) ? s->uvlinesize : s->linesize,
4153 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4154 if (!v->ttmbf && ttmb < 8)
4161 /** Decode one B-frame MB (in interlaced field B picture)
4163 static void vc1_decode_b_mb_intfi(VC1Context *v)
4165 MpegEncContext *s = &v->s;
4166 GetBitContext *gb = &s->gb;
4168 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4169 int cbp = 0; /* cbp decoding stuff */
4170 int mqdiff, mquant; /* MB quantization */
4171 int ttmb = v->ttfrm; /* MB Transform type */
4172 int mb_has_coeffs = 0; /* last_flag */
4173 int val; /* temp value */
4174 int first_block = 1;
4177 int dmv_x[2], dmv_y[2], pred_flag[2];
4178 int bmvtype = BMV_TYPE_BACKWARD;
4179 int idx_mbmode, interpmvp;
4181 mquant = v->pq; /* Loosy initialization */
4184 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4185 if (idx_mbmode <= 1) { // intra MB
4186 s->mb_intra = v->is_intra[s->mb_x] = 1;
4187 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4188 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4189 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4191 s->current_picture.qscale_table[mb_pos] = mquant;
4192 /* Set DC scale - y and c use the same (not sure if necessary here) */
4193 s->y_dc_scale = s->y_dc_scale_table[mquant];
4194 s->c_dc_scale = s->c_dc_scale_table[mquant];
4195 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4196 mb_has_coeffs = idx_mbmode & 1;
4198 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4200 for (i = 0; i < 6; i++) {
4201 s->dc_val[0][s->block_index[i]] = 0;
4203 val = ((cbp >> (5 - i)) & 1);
4204 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4205 v->a_avail = v->c_avail = 0;
4206 if (i == 2 || i == 3 || !s->first_slice_line)
4207 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4208 if (i == 1 || i == 3 || s->mb_x)
4209 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4211 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4212 (i & 4) ? v->codingset2 : v->codingset);
4213 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4215 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4217 for (j = 0; j < 64; j++)
4218 s->block[i][j] <<= 1;
4219 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4220 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4221 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4222 // TODO: yet to perform loop filter
4225 s->mb_intra = v->is_intra[s->mb_x] = 0;
4226 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4227 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4229 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4231 fwd = v->forward_mb_plane[mb_pos];
4232 if (idx_mbmode <= 5) { // 1-MV
4233 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4234 pred_flag[0] = pred_flag[1] = 0;
4236 bmvtype = BMV_TYPE_FORWARD;
4238 bmvtype = decode012(gb);
4241 bmvtype = BMV_TYPE_BACKWARD;
4244 bmvtype = BMV_TYPE_DIRECT;
4247 bmvtype = BMV_TYPE_INTERPOLATED;
4248 interpmvp = get_bits1(gb);
4251 v->bmvtype = bmvtype;
4252 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4253 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4255 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4256 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4258 if (bmvtype == BMV_TYPE_DIRECT) {
4259 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4260 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4262 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4263 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4264 mb_has_coeffs = !(idx_mbmode & 2);
4267 bmvtype = BMV_TYPE_FORWARD;
4268 v->bmvtype = bmvtype;
4269 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4270 for (i = 0; i < 6; i++) {
4272 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4273 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4274 val = ((v->fourmvbp >> (3 - i)) & 1);
4276 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4277 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4278 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4280 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4281 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4283 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4285 mb_has_coeffs = idx_mbmode & 1;
4288 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4292 s->current_picture.qscale_table[mb_pos] = mquant;
4293 if (!v->ttmbf && cbp) {
4294 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4297 for (i = 0; i < 6; i++) {
4298 s->dc_val[0][s->block_index[i]] = 0;
4300 val = ((cbp >> (5 - i)) & 1);
4301 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4302 if (v->cur_field_type)
4303 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4305 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4306 first_block, s->dest[dst_idx] + off,
4307 (i & 4) ? s->uvlinesize : s->linesize,
4308 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4309 if (!v->ttmbf && ttmb < 8)
4317 /** Decode blocks of I-frame
4319 static void vc1_decode_i_blocks(VC1Context *v)
4322 MpegEncContext *s = &v->s;
4327 /* select codingmode used for VLC tables selection */
4328 switch (v->y_ac_table_index) {
4330 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4333 v->codingset = CS_HIGH_MOT_INTRA;
4336 v->codingset = CS_MID_RATE_INTRA;
4340 switch (v->c_ac_table_index) {
4342 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4345 v->codingset2 = CS_HIGH_MOT_INTER;
4348 v->codingset2 = CS_MID_RATE_INTER;
4352 /* Set DC scale - y and c use the same */
4353 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4354 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4357 s->mb_x = s->mb_y = 0;
4359 s->first_slice_line = 1;
4360 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4362 ff_init_block_index(s);
4363 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4365 ff_update_block_index(s);
4366 dst[0] = s->dest[0];
4367 dst[1] = dst[0] + 8;
4368 dst[2] = s->dest[0] + s->linesize * 8;
4369 dst[3] = dst[2] + 8;
4370 dst[4] = s->dest[1];
4371 dst[5] = s->dest[2];
4372 s->dsp.clear_blocks(s->block[0]);
4373 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4374 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4375 s->current_picture.qscale_table[mb_pos] = v->pq;
4376 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4377 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4379 // do actual MB decoding and displaying
4380 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4381 v->s.ac_pred = get_bits1(&v->s.gb);
4383 for (k = 0; k < 6; k++) {
4384 val = ((cbp >> (5 - k)) & 1);
4387 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4391 cbp |= val << (5 - k);
4393 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4395 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4397 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4398 if (v->pq >= 9 && v->overlap) {
4400 for (j = 0; j < 64; j++)
4401 s->block[k][j] <<= 1;
4402 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4405 for (j = 0; j < 64; j++)
4406 s->block[k][j] = (s->block[k][j] - 64) << 1;
4407 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4411 if (v->pq >= 9 && v->overlap) {
4413 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4414 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4415 if (!(s->flags & CODEC_FLAG_GRAY)) {
4416 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4417 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4420 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4421 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4422 if (!s->first_slice_line) {
4423 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4424 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4425 if (!(s->flags & CODEC_FLAG_GRAY)) {
4426 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4427 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4430 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4431 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4433 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4435 if (get_bits_count(&s->gb) > v->bits) {
4436 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4437 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4438 get_bits_count(&s->gb), v->bits);
4442 if (!v->s.loop_filter)
4443 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4445 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4447 s->first_slice_line = 0;
4449 if (v->s.loop_filter)
4450 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4452 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4453 * profile, these only differ are when decoding MSS2 rectangles. */
4454 ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4457 /** Decode blocks of I-frame for advanced profile
4459 static void vc1_decode_i_blocks_adv(VC1Context *v)
4462 MpegEncContext *s = &v->s;
4468 GetBitContext *gb = &s->gb;
4470 /* select codingmode used for VLC tables selection */
4471 switch (v->y_ac_table_index) {
4473 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4476 v->codingset = CS_HIGH_MOT_INTRA;
4479 v->codingset = CS_MID_RATE_INTRA;
4483 switch (v->c_ac_table_index) {
4485 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4488 v->codingset2 = CS_HIGH_MOT_INTER;
4491 v->codingset2 = CS_MID_RATE_INTER;
4496 s->mb_x = s->mb_y = 0;
4498 s->first_slice_line = 1;
4499 s->mb_y = s->start_mb_y;
4500 if (s->start_mb_y) {
4502 ff_init_block_index(s);
4503 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4504 (1 + s->b8_stride) * sizeof(*s->coded_block));
4506 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4508 ff_init_block_index(s);
4509 for (;s->mb_x < s->mb_width; s->mb_x++) {
4510 int16_t (*block)[64] = v->block[v->cur_blk_idx];
4511 ff_update_block_index(s);
4512 s->dsp.clear_blocks(block[0]);
4513 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4514 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4515 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4516 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4518 // do actual MB decoding and displaying
4519 if (v->fieldtx_is_raw)
4520 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4521 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4522 if ( v->acpred_is_raw)
4523 v->s.ac_pred = get_bits1(&v->s.gb);
4525 v->s.ac_pred = v->acpred_plane[mb_pos];
4527 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4528 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4532 s->current_picture.qscale_table[mb_pos] = mquant;
4533 /* Set DC scale - y and c use the same */
4534 s->y_dc_scale = s->y_dc_scale_table[mquant];
4535 s->c_dc_scale = s->c_dc_scale_table[mquant];
4537 for (k = 0; k < 6; k++) {
4538 val = ((cbp >> (5 - k)) & 1);
4541 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4545 cbp |= val << (5 - k);
4547 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4548 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4550 vc1_decode_i_block_adv(v, block[k], k, val,
4551 (k < 4) ? v->codingset : v->codingset2, mquant);
4553 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4555 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4558 vc1_smooth_overlap_filter_iblk(v);
4559 vc1_put_signed_blocks_clamped(v);
4560 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4562 if (get_bits_count(&s->gb) > v->bits) {
4563 // TODO: may need modification to handle slice coding
4564 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4565 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4566 get_bits_count(&s->gb), v->bits);
4570 if (!v->s.loop_filter)
4571 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4573 ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4574 s->first_slice_line = 0;
4577 /* raw bottom MB row */
4579 ff_init_block_index(s);
4580 for (;s->mb_x < s->mb_width; s->mb_x++) {
4581 ff_update_block_index(s);
4582 vc1_put_signed_blocks_clamped(v);
4583 if (v->s.loop_filter)
4584 vc1_loop_filter_iblk_delayed(v, v->pq);
4586 if (v->s.loop_filter)
4587 ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4588 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4589 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4592 static void vc1_decode_p_blocks(VC1Context *v)
4594 MpegEncContext *s = &v->s;
4595 int apply_loop_filter;
4597 /* select codingmode used for VLC tables selection */
4598 switch (v->c_ac_table_index) {
4600 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4603 v->codingset = CS_HIGH_MOT_INTRA;
4606 v->codingset = CS_MID_RATE_INTRA;
4610 switch (v->c_ac_table_index) {
4612 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4615 v->codingset2 = CS_HIGH_MOT_INTER;
4618 v->codingset2 = CS_MID_RATE_INTER;
4622 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY) &&
4623 v->fcm == PROGRESSIVE;
4624 s->first_slice_line = 1;
4625 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
4626 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4628 ff_init_block_index(s);
4629 for (; s->mb_x < s->mb_width; s->mb_x++) {
4630 ff_update_block_index(s);
4632 if (v->fcm == ILACE_FIELD)
4633 vc1_decode_p_mb_intfi(v);
4634 else if (v->fcm == ILACE_FRAME)
4635 vc1_decode_p_mb_intfr(v);
4636 else vc1_decode_p_mb(v);
4637 if (s->mb_y != s->start_mb_y && apply_loop_filter)
4638 vc1_apply_p_loop_filter(v);
4639 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4640 // TODO: may need modification to handle slice coding
4641 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4642 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4643 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4647 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
4648 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
4649 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4650 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
4651 if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4652 s->first_slice_line = 0;
4654 if (apply_loop_filter) {
4656 ff_init_block_index(s);
4657 for (; s->mb_x < s->mb_width; s->mb_x++) {
4658 ff_update_block_index(s);
4659 vc1_apply_p_loop_filter(v);
4662 if (s->end_mb_y >= s->start_mb_y)
4663 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4664 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4665 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4668 static void vc1_decode_b_blocks(VC1Context *v)
4670 MpegEncContext *s = &v->s;
4672 /* select codingmode used for VLC tables selection */
4673 switch (v->c_ac_table_index) {
4675 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4678 v->codingset = CS_HIGH_MOT_INTRA;
4681 v->codingset = CS_MID_RATE_INTRA;
4685 switch (v->c_ac_table_index) {
4687 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4690 v->codingset2 = CS_HIGH_MOT_INTER;
4693 v->codingset2 = CS_MID_RATE_INTER;
4697 s->first_slice_line = 1;
4698 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4700 ff_init_block_index(s);
4701 for (; s->mb_x < s->mb_width; s->mb_x++) {
4702 ff_update_block_index(s);
4704 if (v->fcm == ILACE_FIELD)
4705 vc1_decode_b_mb_intfi(v);
4708 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4709 // TODO: may need modification to handle slice coding
4710 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4711 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4712 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4715 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4717 if (!v->s.loop_filter)
4718 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4720 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4721 s->first_slice_line = 0;
4723 if (v->s.loop_filter)
4724 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4725 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4726 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4729 static void vc1_decode_skip_blocks(VC1Context *v)
4731 MpegEncContext *s = &v->s;
4733 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
4734 s->first_slice_line = 1;
4735 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4737 ff_init_block_index(s);
4738 ff_update_block_index(s);
4739 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4740 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4741 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4742 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4743 s->first_slice_line = 0;
4745 s->pict_type = AV_PICTURE_TYPE_P;
4748 void ff_vc1_decode_blocks(VC1Context *v)
4751 v->s.esc3_level_length = 0;
4753 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
4756 v->left_blk_idx = -1;
4757 v->topleft_blk_idx = 1;
4759 switch (v->s.pict_type) {
4760 case AV_PICTURE_TYPE_I:
4761 if (v->profile == PROFILE_ADVANCED)
4762 vc1_decode_i_blocks_adv(v);
4764 vc1_decode_i_blocks(v);
4766 case AV_PICTURE_TYPE_P:
4767 if (v->p_frame_skipped)
4768 vc1_decode_skip_blocks(v);
4770 vc1_decode_p_blocks(v);
4772 case AV_PICTURE_TYPE_B:
4774 if (v->profile == PROFILE_ADVANCED)
4775 vc1_decode_i_blocks_adv(v);
4777 vc1_decode_i_blocks(v);
4779 vc1_decode_b_blocks(v);
4785 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
4789 * Transform coefficients for both sprites in 16.16 fixed point format,
4790 * in the order they appear in the bitstream:
4792 * rotation 1 (unused)
4794 * rotation 2 (unused)
4801 int effect_type, effect_flag;
4802 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
4803 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
4806 static inline int get_fp_val(GetBitContext* gb)
4808 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
4811 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
4815 switch (get_bits(gb, 2)) {
4818 c[2] = get_fp_val(gb);
4822 c[0] = c[4] = get_fp_val(gb);
4823 c[2] = get_fp_val(gb);
4826 c[0] = get_fp_val(gb);
4827 c[2] = get_fp_val(gb);
4828 c[4] = get_fp_val(gb);
4831 c[0] = get_fp_val(gb);
4832 c[1] = get_fp_val(gb);
4833 c[2] = get_fp_val(gb);
4834 c[3] = get_fp_val(gb);
4835 c[4] = get_fp_val(gb);
4838 c[5] = get_fp_val(gb);
4840 c[6] = get_fp_val(gb);
4845 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
4847 AVCodecContext *avctx = v->s.avctx;
4850 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4851 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
4852 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
4853 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
4854 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
4855 for (i = 0; i < 7; i++)
4856 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
4857 sd->coefs[sprite][i] / (1<<16),
4858 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
4859 av_log(avctx, AV_LOG_DEBUG, "\n");
4863 if (sd->effect_type = get_bits_long(gb, 30)) {
4864 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
4866 vc1_sprite_parse_transform(gb, sd->effect_params1);
4869 vc1_sprite_parse_transform(gb, sd->effect_params1);
4870 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
4873 for (i = 0; i < sd->effect_pcount1; i++)
4874 sd->effect_params1[i] = get_fp_val(gb);
4876 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
4877 // effect 13 is simple alpha blending and matches the opacity above
4878 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
4879 for (i = 0; i < sd->effect_pcount1; i++)
4880 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4881 sd->effect_params1[i] / (1 << 16),
4882 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
4883 av_log(avctx, AV_LOG_DEBUG, "\n");
4886 sd->effect_pcount2 = get_bits(gb, 16);
4887 if (sd->effect_pcount2 > 10) {
4888 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
4890 } else if (sd->effect_pcount2) {
4892 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
4893 while (++i < sd->effect_pcount2) {
4894 sd->effect_params2[i] = get_fp_val(gb);
4895 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4896 sd->effect_params2[i] / (1 << 16),
4897 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
4899 av_log(avctx, AV_LOG_DEBUG, "\n");
4902 if (sd->effect_flag = get_bits1(gb))
4903 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4905 if (get_bits_count(gb) >= gb->size_in_bits +
4906 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
4907 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4908 if (get_bits_count(gb) < gb->size_in_bits - 8)
4909 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4912 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
4914 int i, plane, row, sprite;
4915 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
4916 uint8_t* src_h[2][2];
4917 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
4919 MpegEncContext *s = &v->s;
4921 for (i = 0; i < 2; i++) {
4922 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
4923 xadv[i] = sd->coefs[i][0];
4924 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
4925 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
4927 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
4928 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
4930 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
4932 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
4933 int width = v->output_width>>!!plane;
4935 for (row = 0; row < v->output_height>>!!plane; row++) {
4936 uint8_t *dst = v->sprite_output_frame.data[plane] +
4937 v->sprite_output_frame.linesize[plane] * row;
4939 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4940 uint8_t *iplane = s->current_picture.f.data[plane];
4941 int iline = s->current_picture.f.linesize[plane];
4942 int ycoord = yoff[sprite] + yadv[sprite] * row;
4943 int yline = ycoord >> 16;
4945 ysub[sprite] = ycoord & 0xFFFF;
4947 iplane = s->last_picture.f.data[plane];
4948 iline = s->last_picture.f.linesize[plane];
4950 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
4951 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4952 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
4954 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
4956 if (sr_cache[sprite][0] != yline) {
4957 if (sr_cache[sprite][1] == yline) {
4958 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
4959 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
4961 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
4962 sr_cache[sprite][0] = yline;
4965 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4966 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
4967 iplane + next_line, xoff[sprite],
4968 xadv[sprite], width);
4969 sr_cache[sprite][1] = yline + 1;
4971 src_h[sprite][0] = v->sr_rows[sprite][0];
4972 src_h[sprite][1] = v->sr_rows[sprite][1];
4976 if (!v->two_sprites) {
4978 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
4980 memcpy(dst, src_h[0][0], width);
4983 if (ysub[0] && ysub[1]) {
4984 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
4985 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
4986 } else if (ysub[0]) {
4987 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
4988 src_h[1][0], alpha, width);
4989 } else if (ysub[1]) {
4990 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
4991 src_h[0][0], (1<<16)-1-alpha, width);
4993 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
4999 for (i = 0; i < 2; i++) {
5009 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5011 MpegEncContext *s = &v->s;
5012 AVCodecContext *avctx = s->avctx;
5015 vc1_parse_sprites(v, gb, &sd);
5017 if (!s->current_picture.f.data[0]) {
5018 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5022 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5023 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5027 av_frame_unref(&v->sprite_output_frame);
5028 if (ff_get_buffer(avctx, &v->sprite_output_frame, 0) < 0) {
5029 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5033 vc1_draw_sprites(v, &sd);
5038 static void vc1_sprite_flush(AVCodecContext *avctx)
5040 VC1Context *v = avctx->priv_data;
5041 MpegEncContext *s = &v->s;
5042 AVFrame *f = &s->current_picture.f;
5045 /* Windows Media Image codecs have a convergence interval of two keyframes.
5046 Since we can't enforce it, clear to black the missing sprite. This is
5047 wrong but it looks better than doing nothing. */
5050 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5051 for (i = 0; i < v->sprite_height>>!!plane; i++)
5052 memset(f->data[plane] + i * f->linesize[plane],
5053 plane ? 128 : 0, f->linesize[plane]);
5058 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5060 MpegEncContext *s = &v->s;
5063 /* Allocate mb bitplanes */
5064 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5065 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5066 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5067 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5068 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5069 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5071 v->n_allocated_blks = s->mb_width + 2;
5072 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5073 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5074 v->cbp = v->cbp_base + s->mb_stride;
5075 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5076 v->ttblk = v->ttblk_base + s->mb_stride;
5077 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5078 v->is_intra = v->is_intra_base + s->mb_stride;
5079 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5080 v->luma_mv = v->luma_mv_base + s->mb_stride;
5082 /* allocate block type info in that way so it could be used with s->block_index[] */
5083 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5084 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5085 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5086 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5088 /* allocate memory to store block level MV info */
5089 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5090 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5091 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5092 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5093 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5094 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5095 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
5096 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);
5097 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5098 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5099 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);
5101 /* Init coded blocks info */
5102 if (v->profile == PROFILE_ADVANCED) {
5103 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5105 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5109 ff_intrax8_common_init(&v->x8,s);
5111 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5112 for (i = 0; i < 4; i++)
5113 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5116 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5117 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5124 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5127 for (i = 0; i < 64; i++) {
5128 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5129 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5130 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5131 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5132 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5133 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5139 /** Initialize a VC1/WMV3 decoder
5140 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5141 * @todo TODO: Decypher remaining bits in extra_data
5143 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5145 VC1Context *v = avctx->priv_data;
5146 MpegEncContext *s = &v->s;
5149 /* save the container output size for WMImage */
5150 v->output_width = avctx->width;
5151 v->output_height = avctx->height;
5153 if (!avctx->extradata_size || !avctx->extradata)
5155 if (!(avctx->flags & CODEC_FLAG_GRAY))
5156 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5158 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5159 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5161 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5162 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5164 if (ff_vc1_init_common(v) < 0)
5166 ff_h264chroma_init(&v->h264chroma, 8);
5167 ff_vc1dsp_init(&v->vc1dsp);
5169 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5172 // looks like WMV3 has a sequence header stored in the extradata
5173 // advanced sequence header may be before the first frame
5174 // the last byte of the extradata is a version number, 1 for the
5175 // samples we can decode
5177 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5179 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5182 count = avctx->extradata_size*8 - get_bits_count(&gb);
5184 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5185 count, get_bits(&gb, count));
5186 } else if (count < 0) {
5187 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5189 } else { // VC1/WVC1/WVP2
5190 const uint8_t *start = avctx->extradata;
5191 uint8_t *end = avctx->extradata + avctx->extradata_size;
5192 const uint8_t *next;
5193 int size, buf2_size;
5194 uint8_t *buf2 = NULL;
5195 int seq_initialized = 0, ep_initialized = 0;
5197 if (avctx->extradata_size < 16) {
5198 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5202 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5203 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5205 for (; next < end; start = next) {
5206 next = find_next_marker(start + 4, end);
5207 size = next - start - 4;
5210 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5211 init_get_bits(&gb, buf2, buf2_size * 8);
5212 switch (AV_RB32(start)) {
5213 case VC1_CODE_SEQHDR:
5214 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5218 seq_initialized = 1;
5220 case VC1_CODE_ENTRYPOINT:
5221 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5230 if (!seq_initialized || !ep_initialized) {
5231 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5234 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5237 avctx->profile = v->profile;
5238 if (v->profile == PROFILE_ADVANCED)
5239 avctx->level = v->level;
5241 avctx->has_b_frames = !!avctx->max_b_frames;
5243 s->mb_width = (avctx->coded_width + 15) >> 4;
5244 s->mb_height = (avctx->coded_height + 15) >> 4;
5246 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5247 ff_vc1_init_transposed_scantables(v);
5249 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5254 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5255 v->sprite_width = avctx->coded_width;
5256 v->sprite_height = avctx->coded_height;
5258 avctx->coded_width = avctx->width = v->output_width;
5259 avctx->coded_height = avctx->height = v->output_height;
5261 // prevent 16.16 overflows
5262 if (v->sprite_width > 1 << 14 ||
5263 v->sprite_height > 1 << 14 ||
5264 v->output_width > 1 << 14 ||
5265 v->output_height > 1 << 14) return -1;
5270 /** Close a VC1/WMV3 decoder
5271 * @warning Initial try at using MpegEncContext stuff
5273 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5275 VC1Context *v = avctx->priv_data;
5278 av_frame_unref(&v->sprite_output_frame);
5280 for (i = 0; i < 4; i++)
5281 av_freep(&v->sr_rows[i >> 1][i & 1]);
5282 av_freep(&v->hrd_rate);
5283 av_freep(&v->hrd_buffer);
5284 ff_MPV_common_end(&v->s);
5285 av_freep(&v->mv_type_mb_plane);
5286 av_freep(&v->direct_mb_plane);
5287 av_freep(&v->forward_mb_plane);
5288 av_freep(&v->fieldtx_plane);
5289 av_freep(&v->acpred_plane);
5290 av_freep(&v->over_flags_plane);
5291 av_freep(&v->mb_type_base);
5292 av_freep(&v->blk_mv_type_base);
5293 av_freep(&v->mv_f_base);
5294 av_freep(&v->mv_f_last_base);
5295 av_freep(&v->mv_f_next_base);
5296 av_freep(&v->block);
5297 av_freep(&v->cbp_base);
5298 av_freep(&v->ttblk_base);
5299 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5300 av_freep(&v->luma_mv_base);
5301 ff_intrax8_common_end(&v->x8);
5306 /** Decode a VC1/WMV3 frame
5307 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5309 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5310 int *got_frame, AVPacket *avpkt)
5312 const uint8_t *buf = avpkt->data;
5313 int buf_size = avpkt->size, n_slices = 0, i, ret;
5314 VC1Context *v = avctx->priv_data;
5315 MpegEncContext *s = &v->s;
5316 AVFrame *pict = data;
5317 uint8_t *buf2 = NULL;
5318 const uint8_t *buf_start = buf;
5319 int mb_height, n_slices1;
5324 } *slices = NULL, *tmp;
5326 /* no supplementary picture */
5327 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5328 /* special case for last picture */
5329 if (s->low_delay == 0 && s->next_picture_ptr) {
5330 if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
5332 s->next_picture_ptr = NULL;
5340 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5341 if (v->profile < PROFILE_ADVANCED)
5342 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5344 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5347 //for advanced profile we may need to parse and unescape data
5348 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5350 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5352 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5353 const uint8_t *start, *end, *next;
5357 for (start = buf, end = buf + buf_size; next < end; start = next) {
5358 next = find_next_marker(start + 4, end);
5359 size = next - start - 4;
5360 if (size <= 0) continue;
5361 switch (AV_RB32(start)) {
5362 case VC1_CODE_FRAME:
5363 if (avctx->hwaccel ||
5364 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5366 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5368 case VC1_CODE_FIELD: {
5370 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5374 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5375 if (!slices[n_slices].buf)
5377 buf_size3 = vc1_unescape_buffer(start + 4, size,
5378 slices[n_slices].buf);
5379 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5381 /* assuming that the field marker is at the exact middle,
5382 hope it's correct */
5383 slices[n_slices].mby_start = s->mb_height >> 1;
5384 n_slices1 = n_slices - 1; // index of the last slice of the first field
5388 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5389 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5390 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5391 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5393 case VC1_CODE_SLICE: {
5395 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5399 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5400 if (!slices[n_slices].buf)
5402 buf_size3 = vc1_unescape_buffer(start + 4, size,
5403 slices[n_slices].buf);
5404 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5406 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5412 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5413 const uint8_t *divider;
5416 divider = find_next_marker(buf, buf + buf_size);
5417 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5418 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5420 } else { // found field marker, unescape second field
5421 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5425 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5426 if (!slices[n_slices].buf)
5428 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5429 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5431 slices[n_slices].mby_start = s->mb_height >> 1;
5432 n_slices1 = n_slices - 1;
5435 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5437 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5439 init_get_bits(&s->gb, buf2, buf_size2*8);
5441 init_get_bits(&s->gb, buf, buf_size*8);
5443 if (v->res_sprite) {
5444 v->new_sprite = !get_bits1(&s->gb);
5445 v->two_sprites = get_bits1(&s->gb);
5446 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5447 we're using the sprite compositor. These are intentionally kept separate
5448 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5449 the vc1 one for WVP2 */
5450 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5451 if (v->new_sprite) {
5452 // switch AVCodecContext parameters to those of the sprites
5453 avctx->width = avctx->coded_width = v->sprite_width;
5454 avctx->height = avctx->coded_height = v->sprite_height;
5461 if (s->context_initialized &&
5462 (s->width != avctx->coded_width ||
5463 s->height != avctx->coded_height)) {
5464 ff_vc1_decode_end(avctx);
5467 if (!s->context_initialized) {
5468 if (ff_msmpeg4_decode_init(avctx) < 0 || ff_vc1_decode_init_alloc_tables(v) < 0)
5471 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5473 if (v->profile == PROFILE_ADVANCED) {
5474 s->h_edge_pos = avctx->coded_width;
5475 s->v_edge_pos = avctx->coded_height;
5479 /* We need to set current_picture_ptr before reading the header,
5480 * otherwise we cannot store anything in there. */
5481 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5482 int i = ff_find_unused_picture(s, 0);
5485 s->current_picture_ptr = &s->picture[i];
5488 // do parse frame header
5489 v->pic_header_flag = 0;
5490 if (v->profile < PROFILE_ADVANCED) {
5491 if (ff_vc1_parse_frame_header(v, &s->gb) == -1) {
5495 if (ff_vc1_parse_frame_header_adv(v, &s->gb) == -1) {
5500 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5501 && s->pict_type != AV_PICTURE_TYPE_I) {
5502 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5506 // process pulldown flags
5507 s->current_picture_ptr->f.repeat_pict = 0;
5508 // Pulldown flags are only valid when 'broadcast' has been set.
5509 // So ticks_per_frame will be 2
5512 s->current_picture_ptr->f.repeat_pict = 1;
5513 } else if (v->rptfrm) {
5515 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5518 // for skipping the frame
5519 s->current_picture.f.pict_type = s->pict_type;
5520 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5522 /* skip B-frames if we don't have reference frames */
5523 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
5526 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5527 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5528 avctx->skip_frame >= AVDISCARD_ALL) {
5532 if (s->next_p_frame_damaged) {
5533 if (s->pict_type == AV_PICTURE_TYPE_B)
5536 s->next_p_frame_damaged = 0;
5539 if (ff_MPV_frame_start(s, avctx) < 0) {
5543 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5544 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5546 if ((CONFIG_VC1_VDPAU_DECODER)
5547 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5548 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5549 else if (avctx->hwaccel) {
5550 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
5552 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5554 if (avctx->hwaccel->end_frame(avctx) < 0)
5557 ff_mpeg_er_frame_start(s);
5559 v->bits = buf_size * 8;
5560 v->end_mb_x = s->mb_width;
5561 if (v->field_mode) {
5563 s->current_picture.f.linesize[0] <<= 1;
5564 s->current_picture.f.linesize[1] <<= 1;
5565 s->current_picture.f.linesize[2] <<= 1;
5567 s->uvlinesize <<= 1;
5568 tmp[0] = v->mv_f_last[0];
5569 tmp[1] = v->mv_f_last[1];
5570 v->mv_f_last[0] = v->mv_f_next[0];
5571 v->mv_f_last[1] = v->mv_f_next[1];
5572 v->mv_f_next[0] = v->mv_f[0];
5573 v->mv_f_next[1] = v->mv_f[1];
5574 v->mv_f[0] = tmp[0];
5575 v->mv_f[1] = tmp[1];
5577 mb_height = s->mb_height >> v->field_mode;
5578 for (i = 0; i <= n_slices; i++) {
5579 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5580 if (v->field_mode <= 0) {
5581 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
5582 "picture boundary (%d >= %d)\n", i,
5583 slices[i - 1].mby_start, mb_height);
5586 v->second_field = 1;
5587 v->blocks_off = s->mb_width * s->mb_height << 1;
5588 v->mb_off = s->mb_stride * s->mb_height >> 1;
5590 v->second_field = 0;
5595 v->pic_header_flag = 0;
5596 if (v->field_mode && i == n_slices1 + 2) {
5597 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5598 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
5601 } else if (get_bits1(&s->gb)) {
5602 v->pic_header_flag = 1;
5603 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5604 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
5609 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5610 if (!v->field_mode || v->second_field)
5611 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5613 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5614 ff_vc1_decode_blocks(v);
5616 s->gb = slices[i].gb;
5618 if (v->field_mode) {
5619 v->second_field = 0;
5620 if (s->pict_type == AV_PICTURE_TYPE_B) {
5621 memcpy(v->mv_f_base, v->mv_f_next_base,
5622 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5624 s->current_picture.f.linesize[0] >>= 1;
5625 s->current_picture.f.linesize[1] >>= 1;
5626 s->current_picture.f.linesize[2] >>= 1;
5628 s->uvlinesize >>= 1;
5630 av_dlog(s->avctx, "Consumed %i/%i bits\n",
5631 get_bits_count(&s->gb), s->gb.size_in_bits);
5632 // if (get_bits_count(&s->gb) > buf_size * 8)
5635 ff_er_frame_end(&s->er);
5638 ff_MPV_frame_end(s);
5640 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5642 avctx->width = avctx->coded_width = v->output_width;
5643 avctx->height = avctx->coded_height = v->output_height;
5644 if (avctx->skip_frame >= AVDISCARD_NONREF)
5646 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5647 if (vc1_decode_sprites(v, &s->gb))
5650 if ((ret = av_frame_ref(pict, &v->sprite_output_frame)) < 0)
5654 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5655 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
5657 ff_print_debug_info(s, s->current_picture_ptr);
5658 } else if (s->last_picture_ptr != NULL) {
5659 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
5661 ff_print_debug_info(s, s->last_picture_ptr);
5663 if (s->last_picture_ptr || s->low_delay) {
5670 for (i = 0; i < n_slices; i++)
5671 av_free(slices[i].buf);
5677 for (i = 0; i < n_slices; i++)
5678 av_free(slices[i].buf);
5684 static const AVProfile profiles[] = {
5685 { FF_PROFILE_VC1_SIMPLE, "Simple" },
5686 { FF_PROFILE_VC1_MAIN, "Main" },
5687 { FF_PROFILE_VC1_COMPLEX, "Complex" },
5688 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5689 { FF_PROFILE_UNKNOWN },
5692 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
5694 AV_PIX_FMT_DXVA2_VLD,
5697 AV_PIX_FMT_VAAPI_VLD,
5706 AVCodec ff_vc1_decoder = {
5708 .type = AVMEDIA_TYPE_VIDEO,
5709 .id = AV_CODEC_ID_VC1,
5710 .priv_data_size = sizeof(VC1Context),
5711 .init = vc1_decode_init,
5712 .close = ff_vc1_decode_end,
5713 .decode = vc1_decode_frame,
5714 .flush = ff_mpeg_flush,
5715 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5716 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5717 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
5718 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5721 #if CONFIG_WMV3_DECODER
5722 AVCodec ff_wmv3_decoder = {
5724 .type = AVMEDIA_TYPE_VIDEO,
5725 .id = AV_CODEC_ID_WMV3,
5726 .priv_data_size = sizeof(VC1Context),
5727 .init = vc1_decode_init,
5728 .close = ff_vc1_decode_end,
5729 .decode = vc1_decode_frame,
5730 .flush = ff_mpeg_flush,
5731 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5732 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5733 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
5734 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5738 #if CONFIG_WMV3_VDPAU_DECODER
5739 AVCodec ff_wmv3_vdpau_decoder = {
5740 .name = "wmv3_vdpau",
5741 .type = AVMEDIA_TYPE_VIDEO,
5742 .id = AV_CODEC_ID_WMV3,
5743 .priv_data_size = sizeof(VC1Context),
5744 .init = vc1_decode_init,
5745 .close = ff_vc1_decode_end,
5746 .decode = vc1_decode_frame,
5747 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5748 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5749 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
5750 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5754 #if CONFIG_VC1_VDPAU_DECODER
5755 AVCodec ff_vc1_vdpau_decoder = {
5756 .name = "vc1_vdpau",
5757 .type = AVMEDIA_TYPE_VIDEO,
5758 .id = AV_CODEC_ID_VC1,
5759 .priv_data_size = sizeof(VC1Context),
5760 .init = vc1_decode_init,
5761 .close = ff_vc1_decode_end,
5762 .decode = vc1_decode_frame,
5763 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5764 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5765 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
5766 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5770 #if CONFIG_WMV3IMAGE_DECODER
5771 AVCodec ff_wmv3image_decoder = {
5772 .name = "wmv3image",
5773 .type = AVMEDIA_TYPE_VIDEO,
5774 .id = AV_CODEC_ID_WMV3IMAGE,
5775 .priv_data_size = sizeof(VC1Context),
5776 .init = vc1_decode_init,
5777 .close = ff_vc1_decode_end,
5778 .decode = vc1_decode_frame,
5779 .capabilities = CODEC_CAP_DR1,
5780 .flush = vc1_sprite_flush,
5781 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5782 .pix_fmts = ff_pixfmt_list_420
5786 #if CONFIG_VC1IMAGE_DECODER
5787 AVCodec ff_vc1image_decoder = {
5789 .type = AVMEDIA_TYPE_VIDEO,
5790 .id = AV_CODEC_ID_VC1IMAGE,
5791 .priv_data_size = sizeof(VC1Context),
5792 .init = vc1_decode_init,
5793 .close = ff_vc1_decode_end,
5794 .decode = vc1_decode_frame,
5795 .capabilities = CODEC_CAP_DR1,
5796 .flush = vc1_sprite_flush,
5797 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5798 .pix_fmts = ff_pixfmt_list_420