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
32 #include "mpegvideo.h"
36 #include "vc1acdata.h"
37 #include "msmpeg4data.h"
40 #include "vdpau_internal.h"
45 #define MB_INTRA_VLC_BITS 9
49 // offset tables for interlaced picture MVDATA decoding
50 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
51 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
53 /***********************************************************************/
55 * @name VC-1 Bitplane decoding
73 /** @} */ //imode defines
76 /** @} */ //Bitplane group
78 static void vc1_put_signed_blocks_clamped(VC1Context *v)
80 MpegEncContext *s = &v->s;
81 int topleft_mb_pos, top_mb_pos;
82 int stride_y, fieldtx;
85 /* The put pixels loop is always one MB row behind the decoding loop,
86 * because we can only put pixels when overlap filtering is done, and
87 * for filtering of the bottom edge of a MB, we need the next MB row
89 * Within the row, the put pixels loop is also one MB col behind the
90 * decoding loop. The reason for this is again, because for filtering
91 * of the right MB edge, we need the next MB present. */
92 if (!s->first_slice_line) {
94 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
95 fieldtx = v->fieldtx_plane[topleft_mb_pos];
96 stride_y = s->linesize << fieldtx;
97 v_dist = (16 - fieldtx) >> (fieldtx == 0);
98 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
99 s->dest[0] - 16 * s->linesize - 16,
101 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
102 s->dest[0] - 16 * s->linesize - 8,
104 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
105 s->dest[0] - v_dist * s->linesize - 16,
107 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
108 s->dest[0] - v_dist * s->linesize - 8,
110 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
111 s->dest[1] - 8 * s->uvlinesize - 8,
113 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
114 s->dest[2] - 8 * s->uvlinesize - 8,
117 if (s->mb_x == s->mb_width - 1) {
118 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
119 fieldtx = v->fieldtx_plane[top_mb_pos];
120 stride_y = s->linesize << fieldtx;
121 v_dist = fieldtx ? 15 : 8;
122 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
123 s->dest[0] - 16 * s->linesize,
125 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
126 s->dest[0] - 16 * s->linesize + 8,
128 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
129 s->dest[0] - v_dist * s->linesize,
131 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
132 s->dest[0] - v_dist * s->linesize + 8,
134 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
135 s->dest[1] - 8 * s->uvlinesize,
137 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
138 s->dest[2] - 8 * s->uvlinesize,
143 #define inc_blk_idx(idx) do { \
145 if (idx >= v->n_allocated_blks) \
149 inc_blk_idx(v->topleft_blk_idx);
150 inc_blk_idx(v->top_blk_idx);
151 inc_blk_idx(v->left_blk_idx);
152 inc_blk_idx(v->cur_blk_idx);
155 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
157 MpegEncContext *s = &v->s;
159 if (!s->first_slice_line) {
160 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
162 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
163 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
164 for (j = 0; j < 2; j++) {
165 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
167 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
170 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
172 if (s->mb_y == s->end_mb_y - 1) {
174 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
175 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
176 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
178 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
182 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
184 MpegEncContext *s = &v->s;
187 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
188 * means it runs two rows/cols behind the decoding loop. */
189 if (!s->first_slice_line) {
191 if (s->mb_y >= s->start_mb_y + 2) {
192 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
195 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
196 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
197 for (j = 0; j < 2; j++) {
198 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
200 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
204 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
207 if (s->mb_x == s->mb_width - 1) {
208 if (s->mb_y >= s->start_mb_y + 2) {
209 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
212 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
213 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
214 for (j = 0; j < 2; j++) {
215 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
217 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
221 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
224 if (s->mb_y == s->end_mb_y) {
227 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
228 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
230 for (j = 0; j < 2; j++) {
231 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
236 if (s->mb_x == s->mb_width - 1) {
238 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
239 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
241 for (j = 0; j < 2; j++) {
242 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
250 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
252 MpegEncContext *s = &v->s;
255 if (v->condover == CONDOVER_NONE)
258 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
260 /* Within a MB, the horizontal overlap always runs before the vertical.
261 * To accomplish that, we run the H on left and internal borders of the
262 * currently decoded MB. Then, we wait for the next overlap iteration
263 * to do H overlap on the right edge of this MB, before moving over and
264 * running the V overlap. Therefore, the V overlap makes us trail by one
265 * MB col and the H overlap filter makes us trail by one MB row. This
266 * is reflected in the time at which we run the put_pixels loop. */
267 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
268 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
269 v->over_flags_plane[mb_pos - 1])) {
270 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
271 v->block[v->cur_blk_idx][0]);
272 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
273 v->block[v->cur_blk_idx][2]);
274 if (!(s->flags & CODEC_FLAG_GRAY)) {
275 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
276 v->block[v->cur_blk_idx][4]);
277 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
278 v->block[v->cur_blk_idx][5]);
281 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
282 v->block[v->cur_blk_idx][1]);
283 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
284 v->block[v->cur_blk_idx][3]);
286 if (s->mb_x == s->mb_width - 1) {
287 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
288 v->over_flags_plane[mb_pos - s->mb_stride])) {
289 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
290 v->block[v->cur_blk_idx][0]);
291 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
292 v->block[v->cur_blk_idx][1]);
293 if (!(s->flags & CODEC_FLAG_GRAY)) {
294 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
295 v->block[v->cur_blk_idx][4]);
296 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
297 v->block[v->cur_blk_idx][5]);
300 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
301 v->block[v->cur_blk_idx][2]);
302 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
303 v->block[v->cur_blk_idx][3]);
306 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
307 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
308 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
309 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
310 v->block[v->left_blk_idx][0]);
311 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
312 v->block[v->left_blk_idx][1]);
313 if (!(s->flags & CODEC_FLAG_GRAY)) {
314 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
315 v->block[v->left_blk_idx][4]);
316 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
317 v->block[v->left_blk_idx][5]);
320 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
321 v->block[v->left_blk_idx][2]);
322 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
323 v->block[v->left_blk_idx][3]);
327 /** Do motion compensation over 1 macroblock
328 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
330 static void vc1_mc_1mv(VC1Context *v, int dir)
332 MpegEncContext *s = &v->s;
333 DSPContext *dsp = &v->s.dsp;
334 uint8_t *srcY, *srcU, *srcV;
335 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
337 int v_edge_pos = s->v_edge_pos >> v->field_mode;
339 if ((!v->field_mode ||
340 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
341 !v->s.last_picture.f.data[0])
344 mx = s->mv[dir][0][0];
345 my = s->mv[dir][0][1];
347 // store motion vectors for further use in B frames
348 if (s->pict_type == AV_PICTURE_TYPE_P) {
349 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
350 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
353 uvmx = (mx + ((mx & 3) == 3)) >> 1;
354 uvmy = (my + ((my & 3) == 3)) >> 1;
355 v->luma_mv[s->mb_x][0] = uvmx;
356 v->luma_mv[s->mb_x][1] = uvmy;
359 v->cur_field_type != v->ref_field_type[dir]) {
360 my = my - 2 + 4 * v->cur_field_type;
361 uvmy = uvmy - 2 + 4 * v->cur_field_type;
364 // fastuvmc shall be ignored for interlaced frame picture
365 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
366 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
367 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
369 if (v->field_mode) { // interlaced field picture
371 if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type) {
372 srcY = s->current_picture.f.data[0];
373 srcU = s->current_picture.f.data[1];
374 srcV = s->current_picture.f.data[2];
376 srcY = s->last_picture.f.data[0];
377 srcU = s->last_picture.f.data[1];
378 srcV = s->last_picture.f.data[2];
381 srcY = s->next_picture.f.data[0];
382 srcU = s->next_picture.f.data[1];
383 srcV = s->next_picture.f.data[2];
387 srcY = s->last_picture.f.data[0];
388 srcU = s->last_picture.f.data[1];
389 srcV = s->last_picture.f.data[2];
391 srcY = s->next_picture.f.data[0];
392 srcU = s->next_picture.f.data[1];
393 srcV = s->next_picture.f.data[2];
397 src_x = s->mb_x * 16 + (mx >> 2);
398 src_y = s->mb_y * 16 + (my >> 2);
399 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
400 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
402 if (v->profile != PROFILE_ADVANCED) {
403 src_x = av_clip( src_x, -16, s->mb_width * 16);
404 src_y = av_clip( src_y, -16, s->mb_height * 16);
405 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
406 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
408 src_x = av_clip( src_x, -17, s->avctx->coded_width);
409 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
410 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
411 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
414 srcY += src_y * s->linesize + src_x;
415 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
416 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
418 if (v->field_mode && v->ref_field_type[dir]) {
419 srcY += s->current_picture_ptr->f.linesize[0];
420 srcU += s->current_picture_ptr->f.linesize[1];
421 srcV += s->current_picture_ptr->f.linesize[2];
424 /* for grayscale we should not try to read from unknown area */
425 if (s->flags & CODEC_FLAG_GRAY) {
426 srcU = s->edge_emu_buffer + 18 * s->linesize;
427 srcV = s->edge_emu_buffer + 18 * s->linesize;
430 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
431 || s->h_edge_pos < 22 || v_edge_pos < 22
432 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
433 || (unsigned)(src_y - s->mspel) > v_edge_pos - (my&3) - 16 - s->mspel * 3) {
434 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
436 srcY -= s->mspel * (1 + s->linesize);
437 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
438 17 + s->mspel * 2, 17 + s->mspel * 2,
439 src_x - s->mspel, src_y - s->mspel,
440 s->h_edge_pos, v_edge_pos);
441 srcY = s->edge_emu_buffer;
442 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
443 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
444 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
445 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
448 /* if we deal with range reduction we need to scale source blocks */
449 if (v->rangeredfrm) {
454 for (j = 0; j < 17 + s->mspel * 2; j++) {
455 for (i = 0; i < 17 + s->mspel * 2; i++)
456 src[i] = ((src[i] - 128) >> 1) + 128;
461 for (j = 0; j < 9; j++) {
462 for (i = 0; i < 9; i++) {
463 src[i] = ((src[i] - 128) >> 1) + 128;
464 src2[i] = ((src2[i] - 128) >> 1) + 128;
466 src += s->uvlinesize;
467 src2 += s->uvlinesize;
470 /* if we deal with intensity compensation we need to scale source blocks */
471 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
476 for (j = 0; j < 17 + s->mspel * 2; j++) {
477 for (i = 0; i < 17 + s->mspel * 2; i++)
478 src[i] = v->luty[src[i]];
483 for (j = 0; j < 9; j++) {
484 for (i = 0; i < 9; i++) {
485 src[i] = v->lutuv[src[i]];
486 src2[i] = v->lutuv[src2[i]];
488 src += s->uvlinesize;
489 src2 += s->uvlinesize;
492 srcY += s->mspel * (1 + s->linesize);
495 if (v->field_mode && v->cur_field_type) {
496 off = s->current_picture_ptr->f.linesize[0];
497 off_uv = s->current_picture_ptr->f.linesize[1];
503 dxy = ((my & 3) << 2) | (mx & 3);
504 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
505 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
506 srcY += s->linesize * 8;
507 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
508 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
509 } else { // hpel mc - always used for luma
510 dxy = (my & 2) | ((mx & 2) >> 1);
512 dsp->put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
514 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
517 if (s->flags & CODEC_FLAG_GRAY) return;
518 /* Chroma MC always uses qpel bilinear */
519 uvmx = (uvmx & 3) << 1;
520 uvmy = (uvmy & 3) << 1;
522 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
523 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
525 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
526 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
530 static inline int median4(int a, int b, int c, int d)
533 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
534 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
536 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
537 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
541 /** Do motion compensation for 4-MV macroblock - luminance block
543 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
545 MpegEncContext *s = &v->s;
546 DSPContext *dsp = &v->s.dsp;
548 int dxy, mx, my, src_x, src_y;
550 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
551 int v_edge_pos = s->v_edge_pos >> v->field_mode;
553 if ((!v->field_mode ||
554 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
555 !v->s.last_picture.f.data[0])
558 mx = s->mv[dir][n][0];
559 my = s->mv[dir][n][1];
563 if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type)
564 srcY = s->current_picture.f.data[0];
566 srcY = s->last_picture.f.data[0];
568 srcY = s->last_picture.f.data[0];
570 srcY = s->next_picture.f.data[0];
573 if (v->cur_field_type != v->ref_field_type[dir])
574 my = my - 2 + 4 * v->cur_field_type;
577 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
578 int same_count = 0, opp_count = 0, k;
579 int chosen_mv[2][4][2], f;
581 for (k = 0; k < 4; k++) {
582 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
583 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
584 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
588 f = opp_count > same_count;
589 switch (f ? opp_count : same_count) {
591 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
592 chosen_mv[f][2][0], chosen_mv[f][3][0]);
593 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
594 chosen_mv[f][2][1], chosen_mv[f][3][1]);
597 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
598 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
601 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
602 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
605 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
606 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
607 for (k = 0; k < 4; k++)
608 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
611 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
613 int width = s->avctx->coded_width;
614 int height = s->avctx->coded_height >> 1;
615 qx = (s->mb_x * 16) + (mx >> 2);
616 qy = (s->mb_y * 8) + (my >> 3);
621 mx -= 4 * (qx - width);
624 else if (qy > height + 1)
625 my -= 8 * (qy - height - 1);
628 if ((v->fcm == ILACE_FRAME) && fieldmv)
629 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
631 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
632 if (v->field_mode && v->cur_field_type)
633 off += s->current_picture_ptr->f.linesize[0];
635 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
637 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
639 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
641 if (v->profile != PROFILE_ADVANCED) {
642 src_x = av_clip(src_x, -16, s->mb_width * 16);
643 src_y = av_clip(src_y, -16, s->mb_height * 16);
645 src_x = av_clip(src_x, -17, s->avctx->coded_width);
646 if (v->fcm == ILACE_FRAME) {
648 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
650 src_y = av_clip(src_y, -18, s->avctx->coded_height);
652 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
656 srcY += src_y * s->linesize + src_x;
657 if (v->field_mode && v->ref_field_type[dir])
658 srcY += s->current_picture_ptr->f.linesize[0];
660 if (fieldmv && !(src_y & 1))
662 if (fieldmv && (src_y & 1) && src_y < 4)
664 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
665 || s->h_edge_pos < 13 || v_edge_pos < 23
666 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
667 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
668 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
669 /* check emulate edge stride and offset */
670 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
671 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
672 src_x - s->mspel, src_y - (s->mspel << fieldmv),
673 s->h_edge_pos, v_edge_pos);
674 srcY = s->edge_emu_buffer;
675 /* if we deal with range reduction we need to scale source blocks */
676 if (v->rangeredfrm) {
681 for (j = 0; j < 9 + s->mspel * 2; j++) {
682 for (i = 0; i < 9 + s->mspel * 2; i++)
683 src[i] = ((src[i] - 128) >> 1) + 128;
684 src += s->linesize << fieldmv;
687 /* if we deal with intensity compensation we need to scale source blocks */
688 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
693 for (j = 0; j < 9 + s->mspel * 2; j++) {
694 for (i = 0; i < 9 + s->mspel * 2; i++)
695 src[i] = v->luty[src[i]];
696 src += s->linesize << fieldmv;
699 srcY += s->mspel * (1 + (s->linesize << fieldmv));
703 dxy = ((my & 3) << 2) | (mx & 3);
704 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
705 } else { // hpel mc - always used for luma
706 dxy = (my & 2) | ((mx & 2) >> 1);
708 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
710 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
714 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
717 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
719 idx = ((a[3] != flag) << 3)
720 | ((a[2] != flag) << 2)
721 | ((a[1] != flag) << 1)
724 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
725 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
727 } else if (count[idx] == 1) {
730 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
731 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
734 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
735 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
738 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
739 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
742 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
743 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
746 } else if (count[idx] == 2) {
748 for (i = 0; i < 3; i++)
753 for (i = t1 + 1; i < 4; i++)
758 *tx = (mvx[t1] + mvx[t2]) / 2;
759 *ty = (mvy[t1] + mvy[t2]) / 2;
767 /** Do motion compensation for 4-MV macroblock - both chroma blocks
769 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
771 MpegEncContext *s = &v->s;
772 DSPContext *dsp = &v->s.dsp;
773 uint8_t *srcU, *srcV;
774 int uvmx, uvmy, uvsrc_x, uvsrc_y;
775 int k, tx = 0, ty = 0;
776 int mvx[4], mvy[4], intra[4], mv_f[4];
778 int chroma_ref_type = v->cur_field_type, off = 0;
779 int v_edge_pos = s->v_edge_pos >> v->field_mode;
781 if (!v->field_mode && !v->s.last_picture.f.data[0])
783 if (s->flags & CODEC_FLAG_GRAY)
786 for (k = 0; k < 4; k++) {
787 mvx[k] = s->mv[dir][k][0];
788 mvy[k] = s->mv[dir][k][1];
789 intra[k] = v->mb_type[0][s->block_index[k]];
791 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
794 /* calculate chroma MV vector from four luma MVs */
795 if (!v->field_mode || (v->field_mode && !v->numref)) {
796 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
798 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
799 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
800 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
801 return; //no need to do MC for intra blocks
805 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
807 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
809 chroma_ref_type = !v->cur_field_type;
811 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
813 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
814 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
815 uvmx = (tx + ((tx & 3) == 3)) >> 1;
816 uvmy = (ty + ((ty & 3) == 3)) >> 1;
818 v->luma_mv[s->mb_x][0] = uvmx;
819 v->luma_mv[s->mb_x][1] = uvmy;
822 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
823 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
825 // Field conversion bias
826 if (v->cur_field_type != chroma_ref_type)
827 uvmy += 2 - 4 * chroma_ref_type;
829 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
830 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
832 if (v->profile != PROFILE_ADVANCED) {
833 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
834 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
836 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
837 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
842 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
843 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
844 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
846 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
847 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
850 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
851 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
854 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
855 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
859 if (chroma_ref_type) {
860 srcU += s->current_picture_ptr->f.linesize[1];
861 srcV += s->current_picture_ptr->f.linesize[2];
863 off = v->cur_field_type ? s->current_picture_ptr->f.linesize[1] : 0;
866 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
867 || s->h_edge_pos < 18 || v_edge_pos < 18
868 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
869 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
870 s->dsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
871 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
872 s->h_edge_pos >> 1, v_edge_pos >> 1);
873 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
874 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
875 s->h_edge_pos >> 1, v_edge_pos >> 1);
876 srcU = s->edge_emu_buffer;
877 srcV = s->edge_emu_buffer + 16;
879 /* if we deal with range reduction we need to scale source blocks */
880 if (v->rangeredfrm) {
886 for (j = 0; j < 9; j++) {
887 for (i = 0; i < 9; i++) {
888 src[i] = ((src[i] - 128) >> 1) + 128;
889 src2[i] = ((src2[i] - 128) >> 1) + 128;
891 src += s->uvlinesize;
892 src2 += s->uvlinesize;
895 /* if we deal with intensity compensation we need to scale source blocks */
896 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
902 for (j = 0; j < 9; j++) {
903 for (i = 0; i < 9; i++) {
904 src[i] = v->lutuv[src[i]];
905 src2[i] = v->lutuv[src2[i]];
907 src += s->uvlinesize;
908 src2 += s->uvlinesize;
913 /* Chroma MC always uses qpel bilinear */
914 uvmx = (uvmx & 3) << 1;
915 uvmy = (uvmy & 3) << 1;
917 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
918 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
920 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
921 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
925 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
927 static void vc1_mc_4mv_chroma4(VC1Context *v)
929 MpegEncContext *s = &v->s;
930 DSPContext *dsp = &v->s.dsp;
931 uint8_t *srcU, *srcV;
932 int uvsrc_x, uvsrc_y;
933 int uvmx_field[4], uvmy_field[4];
935 int fieldmv = v->blk_mv_type[s->block_index[0]];
936 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
937 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
938 int v_edge_pos = s->v_edge_pos >> 1;
940 if (!v->s.last_picture.f.data[0])
942 if (s->flags & CODEC_FLAG_GRAY)
945 for (i = 0; i < 4; i++) {
947 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
950 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
952 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
955 for (i = 0; i < 4; i++) {
956 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
957 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
958 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
959 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
960 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
961 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
962 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
963 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
964 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
965 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
967 if (fieldmv && !(uvsrc_y & 1))
969 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
971 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
972 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
973 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
974 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
975 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
976 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
977 s->h_edge_pos >> 1, v_edge_pos);
978 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
979 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
980 s->h_edge_pos >> 1, v_edge_pos);
981 srcU = s->edge_emu_buffer;
982 srcV = s->edge_emu_buffer + 16;
984 /* if we deal with intensity compensation we need to scale source blocks */
985 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
991 for (j = 0; j < 5; j++) {
992 for (i = 0; i < 5; i++) {
993 src[i] = v->lutuv[src[i]];
994 src2[i] = v->lutuv[src2[i]];
996 src += s->uvlinesize << 1;
997 src2 += s->uvlinesize << 1;
1002 dsp->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1003 dsp->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1005 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]);
1006 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]);
1011 /***********************************************************************/
1013 * @name VC-1 Block-level functions
1014 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1020 * @brief Get macroblock-level quantizer scale
1022 #define GET_MQUANT() \
1023 if (v->dquantfrm) { \
1025 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1026 if (v->dqbilevel) { \
1027 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1029 mqdiff = get_bits(gb, 3); \
1031 mquant = v->pq + mqdiff; \
1033 mquant = get_bits(gb, 5); \
1036 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1037 edges = 1 << v->dqsbedge; \
1038 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1039 edges = (3 << v->dqsbedge) % 15; \
1040 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1042 if ((edges&1) && !s->mb_x) \
1043 mquant = v->altpq; \
1044 if ((edges&2) && s->first_slice_line) \
1045 mquant = v->altpq; \
1046 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1047 mquant = v->altpq; \
1048 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1049 mquant = v->altpq; \
1050 if (!mquant || mquant > 31) { \
1051 av_log(v->s.avctx, AV_LOG_ERROR, \
1052 "Overriding invalid mquant %d\n", mquant); \
1058 * @def GET_MVDATA(_dmv_x, _dmv_y)
1059 * @brief Get MV differentials
1060 * @see MVDATA decoding from 8.3.5.2, p(1)20
1061 * @param _dmv_x Horizontal differential for decoded MV
1062 * @param _dmv_y Vertical differential for decoded MV
1064 #define GET_MVDATA(_dmv_x, _dmv_y) \
1065 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1066 VC1_MV_DIFF_VLC_BITS, 2); \
1068 mb_has_coeffs = 1; \
1071 mb_has_coeffs = 0; \
1074 _dmv_x = _dmv_y = 0; \
1075 } else if (index == 35) { \
1076 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1077 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1078 } else if (index == 36) { \
1083 index1 = index % 6; \
1084 if (!s->quarter_sample && index1 == 5) val = 1; \
1086 if (size_table[index1] - val > 0) \
1087 val = get_bits(gb, size_table[index1] - val); \
1089 sign = 0 - (val&1); \
1090 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1092 index1 = index / 6; \
1093 if (!s->quarter_sample && index1 == 5) val = 1; \
1095 if (size_table[index1] - val > 0) \
1096 val = get_bits(gb, size_table[index1] - val); \
1098 sign = 0 - (val & 1); \
1099 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1102 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1103 int *dmv_y, int *pred_flag)
1106 int extend_x = 0, extend_y = 0;
1107 GetBitContext *gb = &v->s.gb;
1110 const int* offs_tab;
1113 bits = VC1_2REF_MVDATA_VLC_BITS;
1116 bits = VC1_1REF_MVDATA_VLC_BITS;
1119 switch (v->dmvrange) {
1127 extend_x = extend_y = 1;
1130 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1132 *dmv_x = get_bits(gb, v->k_x);
1133 *dmv_y = get_bits(gb, v->k_y);
1135 *pred_flag = *dmv_y & 1;
1136 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1141 offs_tab = offset_table2;
1143 offs_tab = offset_table1;
1144 index1 = (index + 1) % 9;
1146 val = get_bits(gb, index1 + extend_x);
1147 sign = 0 -(val & 1);
1148 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1152 offs_tab = offset_table2;
1154 offs_tab = offset_table1;
1155 index1 = (index + 1) / 9;
1156 if (index1 > v->numref) {
1157 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1158 sign = 0 - (val & 1);
1159 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1163 *pred_flag = index1 & 1;
1167 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1169 int scaledvalue, refdist;
1170 int scalesame1, scalesame2;
1171 int scalezone1_x, zone1offset_x;
1172 int table_index = dir ^ v->second_field;
1174 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1175 refdist = v->refdist;
1177 refdist = dir ? v->brfd : v->frfd;
1180 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1181 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1182 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1183 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1188 if (FFABS(n) < scalezone1_x)
1189 scaledvalue = (n * scalesame1) >> 8;
1192 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1194 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1197 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1200 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1202 int scaledvalue, refdist;
1203 int scalesame1, scalesame2;
1204 int scalezone1_y, zone1offset_y;
1205 int table_index = dir ^ v->second_field;
1207 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1208 refdist = v->refdist;
1210 refdist = dir ? v->brfd : v->frfd;
1213 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1214 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1215 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1216 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1221 if (FFABS(n) < scalezone1_y)
1222 scaledvalue = (n * scalesame1) >> 8;
1225 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1227 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1231 if (v->cur_field_type && !v->ref_field_type[dir])
1232 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1234 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1237 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1239 int scalezone1_x, zone1offset_x;
1240 int scaleopp1, scaleopp2, brfd;
1243 brfd = FFMIN(v->brfd, 3);
1244 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1245 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1246 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1247 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1252 if (FFABS(n) < scalezone1_x)
1253 scaledvalue = (n * scaleopp1) >> 8;
1256 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1258 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1261 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1264 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1266 int scalezone1_y, zone1offset_y;
1267 int scaleopp1, scaleopp2, brfd;
1270 brfd = FFMIN(v->brfd, 3);
1271 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1272 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1273 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1274 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1279 if (FFABS(n) < scalezone1_y)
1280 scaledvalue = (n * scaleopp1) >> 8;
1283 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1285 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1288 if (v->cur_field_type && !v->ref_field_type[dir]) {
1289 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1291 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1295 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1298 int brfd, scalesame;
1299 int hpel = 1 - v->s.quarter_sample;
1302 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1304 n = scaleforsame_y(v, i, n, dir) << hpel;
1306 n = scaleforsame_x(v, n, dir) << hpel;
1309 brfd = FFMIN(v->brfd, 3);
1310 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1312 n = (n * scalesame >> 8) << hpel;
1316 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1319 int refdist, scaleopp;
1320 int hpel = 1 - v->s.quarter_sample;
1323 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1325 n = scaleforopp_y(v, n, dir) << hpel;
1327 n = scaleforopp_x(v, n) << hpel;
1330 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1331 refdist = FFMIN(v->refdist, 3);
1333 refdist = dir ? v->brfd : v->frfd;
1334 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1336 n = (n * scaleopp >> 8) << hpel;
1340 /** Predict and set motion vector
1342 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1343 int mv1, int r_x, int r_y, uint8_t* is_intra,
1344 int pred_flag, int dir)
1346 MpegEncContext *s = &v->s;
1347 int xy, wrap, off = 0;
1351 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1352 int opposit, a_f, b_f, c_f;
1353 int16_t field_predA[2];
1354 int16_t field_predB[2];
1355 int16_t field_predC[2];
1356 int a_valid, b_valid, c_valid;
1357 int hybridmv_thresh, y_bias = 0;
1359 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1360 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1364 /* scale MV difference to be quad-pel */
1365 dmv_x <<= 1 - s->quarter_sample;
1366 dmv_y <<= 1 - s->quarter_sample;
1368 wrap = s->b8_stride;
1369 xy = s->block_index[n];
1372 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
1373 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
1374 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
1375 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
1376 if (mv1) { /* duplicate motion data for 1-MV block */
1377 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1378 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1379 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1380 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1381 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1382 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1383 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1384 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1385 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1386 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1387 s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1388 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1389 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1394 C = s->current_picture.f.motion_val[dir][xy - 1 + v->blocks_off];
1395 A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
1397 if (v->field_mode && mixedmv_pic)
1398 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1400 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1402 //in 4-MV mode different blocks have different B predictor position
1405 off = (s->mb_x > 0) ? -1 : 1;
1408 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1417 B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
1419 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1420 b_valid = a_valid && (s->mb_width > 1);
1421 c_valid = s->mb_x || (n == 1 || n == 3);
1422 if (v->field_mode) {
1423 a_valid = a_valid && !is_intra[xy - wrap];
1424 b_valid = b_valid && !is_intra[xy - wrap + off];
1425 c_valid = c_valid && !is_intra[xy - 1];
1429 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1430 num_oppfield += a_f;
1431 num_samefield += 1 - a_f;
1432 field_predA[0] = A[0];
1433 field_predA[1] = A[1];
1435 field_predA[0] = field_predA[1] = 0;
1439 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1440 num_oppfield += b_f;
1441 num_samefield += 1 - b_f;
1442 field_predB[0] = B[0];
1443 field_predB[1] = B[1];
1445 field_predB[0] = field_predB[1] = 0;
1449 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1450 num_oppfield += c_f;
1451 num_samefield += 1 - c_f;
1452 field_predC[0] = C[0];
1453 field_predC[1] = C[1];
1455 field_predC[0] = field_predC[1] = 0;
1459 if (v->field_mode) {
1460 if (num_samefield <= num_oppfield)
1461 opposit = 1 - pred_flag;
1463 opposit = pred_flag;
1467 if (a_valid && !a_f) {
1468 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1469 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1471 if (b_valid && !b_f) {
1472 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1473 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1475 if (c_valid && !c_f) {
1476 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1477 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1479 v->mv_f[dir][xy + v->blocks_off] = 1;
1480 v->ref_field_type[dir] = !v->cur_field_type;
1482 if (a_valid && a_f) {
1483 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1484 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1486 if (b_valid && b_f) {
1487 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1488 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1490 if (c_valid && c_f) {
1491 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1492 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1494 v->mv_f[dir][xy + v->blocks_off] = 0;
1495 v->ref_field_type[dir] = v->cur_field_type;
1499 px = field_predA[0];
1500 py = field_predA[1];
1501 } else if (c_valid) {
1502 px = field_predC[0];
1503 py = field_predC[1];
1504 } else if (b_valid) {
1505 px = field_predB[0];
1506 py = field_predB[1];
1512 if (num_samefield + num_oppfield > 1) {
1513 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1514 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1517 /* Pullback MV as specified in 8.3.5.3.4 */
1518 if (!v->field_mode) {
1520 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1521 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1522 X = (s->mb_width << 6) - 4;
1523 Y = (s->mb_height << 6) - 4;
1525 if (qx + px < -60) px = -60 - qx;
1526 if (qy + py < -60) py = -60 - qy;
1528 if (qx + px < -28) px = -28 - qx;
1529 if (qy + py < -28) py = -28 - qy;
1531 if (qx + px > X) px = X - qx;
1532 if (qy + py > Y) py = Y - qy;
1535 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1536 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1537 hybridmv_thresh = 32;
1538 if (a_valid && c_valid) {
1539 if (is_intra[xy - wrap])
1540 sum = FFABS(px) + FFABS(py);
1542 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1543 if (sum > hybridmv_thresh) {
1544 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1545 px = field_predA[0];
1546 py = field_predA[1];
1548 px = field_predC[0];
1549 py = field_predC[1];
1552 if (is_intra[xy - 1])
1553 sum = FFABS(px) + FFABS(py);
1555 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1556 if (sum > hybridmv_thresh) {
1557 if (get_bits1(&s->gb)) {
1558 px = field_predA[0];
1559 py = field_predA[1];
1561 px = field_predC[0];
1562 py = field_predC[1];
1569 if (v->field_mode && !s->quarter_sample) {
1573 if (v->field_mode && v->numref)
1575 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1577 /* store MV using signed modulus of MV range defined in 4.11 */
1578 s->mv[dir][n][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1579 s->mv[dir][n][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
1580 if (mv1) { /* duplicate motion data for 1-MV block */
1581 s->current_picture.f.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1582 s->current_picture.f.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1583 s->current_picture.f.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1584 s->current_picture.f.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1585 s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1586 s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1587 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1588 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];
1592 /** Predict and set motion vector for interlaced frame picture MBs
1594 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1595 int mvn, int r_x, int r_y, uint8_t* is_intra)
1597 MpegEncContext *s = &v->s;
1598 int xy, wrap, off = 0;
1599 int A[2], B[2], C[2];
1601 int a_valid = 0, b_valid = 0, c_valid = 0;
1602 int field_a, field_b, field_c; // 0: same, 1: opposit
1603 int total_valid, num_samefield, num_oppfield;
1604 int pos_c, pos_b, n_adj;
1606 wrap = s->b8_stride;
1607 xy = s->block_index[n];
1610 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
1611 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
1612 s->current_picture.f.motion_val[1][xy][0] = 0;
1613 s->current_picture.f.motion_val[1][xy][1] = 0;
1614 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1615 s->current_picture.f.motion_val[0][xy + 1][0] = 0;
1616 s->current_picture.f.motion_val[0][xy + 1][1] = 0;
1617 s->current_picture.f.motion_val[0][xy + wrap][0] = 0;
1618 s->current_picture.f.motion_val[0][xy + wrap][1] = 0;
1619 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
1620 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
1621 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1622 s->current_picture.f.motion_val[1][xy + 1][0] = 0;
1623 s->current_picture.f.motion_val[1][xy + 1][1] = 0;
1624 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1625 s->current_picture.f.motion_val[1][xy + wrap][1] = 0;
1626 s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
1627 s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
1632 off = ((n == 0) || (n == 1)) ? 1 : -1;
1634 if (s->mb_x || (n == 1) || (n == 3)) {
1635 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1636 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1637 A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
1638 A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
1640 } else { // current block has frame mv and cand. has field MV (so average)
1641 A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
1642 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1643 A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
1644 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1647 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1653 /* Predict B and C */
1654 B[0] = B[1] = C[0] = C[1] = 0;
1655 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1656 if (!s->first_slice_line) {
1657 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1660 pos_b = s->block_index[n_adj] - 2 * wrap;
1661 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1662 n_adj = (n & 2) | (n & 1);
1664 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1665 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1666 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1667 B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1668 B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1671 if (s->mb_width > 1) {
1672 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1675 pos_c = s->block_index[2] - 2 * wrap + 2;
1676 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1679 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1680 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1681 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1682 C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1683 C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1685 if (s->mb_x == s->mb_width - 1) {
1686 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1689 pos_c = s->block_index[3] - 2 * wrap - 2;
1690 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1693 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1694 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1695 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1696 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1697 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1706 pos_b = s->block_index[1];
1708 B[0] = s->current_picture.f.motion_val[0][pos_b][0];
1709 B[1] = s->current_picture.f.motion_val[0][pos_b][1];
1710 pos_c = s->block_index[0];
1712 C[0] = s->current_picture.f.motion_val[0][pos_c][0];
1713 C[1] = s->current_picture.f.motion_val[0][pos_c][1];
1716 total_valid = a_valid + b_valid + c_valid;
1717 // check if predictor A is out of bounds
1718 if (!s->mb_x && !(n == 1 || n == 3)) {
1721 // check if predictor B is out of bounds
1722 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1723 B[0] = B[1] = C[0] = C[1] = 0;
1725 if (!v->blk_mv_type[xy]) {
1726 if (s->mb_width == 1) {
1730 if (total_valid >= 2) {
1731 px = mid_pred(A[0], B[0], C[0]);
1732 py = mid_pred(A[1], B[1], C[1]);
1733 } else if (total_valid) {
1734 if (a_valid) { px = A[0]; py = A[1]; }
1735 if (b_valid) { px = B[0]; py = B[1]; }
1736 if (c_valid) { px = C[0]; py = C[1]; }
1742 field_a = (A[1] & 4) ? 1 : 0;
1746 field_b = (B[1] & 4) ? 1 : 0;
1750 field_c = (C[1] & 4) ? 1 : 0;
1754 num_oppfield = field_a + field_b + field_c;
1755 num_samefield = total_valid - num_oppfield;
1756 if (total_valid == 3) {
1757 if ((num_samefield == 3) || (num_oppfield == 3)) {
1758 px = mid_pred(A[0], B[0], C[0]);
1759 py = mid_pred(A[1], B[1], C[1]);
1760 } else if (num_samefield >= num_oppfield) {
1761 /* take one MV from same field set depending on priority
1762 the check for B may not be necessary */
1763 px = !field_a ? A[0] : B[0];
1764 py = !field_a ? A[1] : B[1];
1766 px = field_a ? A[0] : B[0];
1767 py = field_a ? A[1] : B[1];
1769 } else if (total_valid == 2) {
1770 if (num_samefield >= num_oppfield) {
1771 if (!field_a && a_valid) {
1774 } else if (!field_b && b_valid) {
1777 } else if (c_valid) {
1782 if (field_a && a_valid) {
1785 } else if (field_b && b_valid) {
1788 } else if (c_valid) {
1793 } else if (total_valid == 1) {
1794 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1795 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1800 /* store MV using signed modulus of MV range defined in 4.11 */
1801 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1802 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1803 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1804 s->current_picture.f.motion_val[0][xy + 1 ][0] = s->current_picture.f.motion_val[0][xy][0];
1805 s->current_picture.f.motion_val[0][xy + 1 ][1] = s->current_picture.f.motion_val[0][xy][1];
1806 s->current_picture.f.motion_val[0][xy + wrap ][0] = s->current_picture.f.motion_val[0][xy][0];
1807 s->current_picture.f.motion_val[0][xy + wrap ][1] = s->current_picture.f.motion_val[0][xy][1];
1808 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1809 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1810 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1811 s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1812 s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1813 s->mv[0][n + 1][0] = s->mv[0][n][0];
1814 s->mv[0][n + 1][1] = s->mv[0][n][1];
1818 /** Motion compensation for direct or interpolated blocks in B-frames
1820 static void vc1_interp_mc(VC1Context *v)
1822 MpegEncContext *s = &v->s;
1823 DSPContext *dsp = &v->s.dsp;
1824 uint8_t *srcY, *srcU, *srcV;
1825 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1827 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1829 if (!v->field_mode && !v->s.next_picture.f.data[0])
1832 mx = s->mv[1][0][0];
1833 my = s->mv[1][0][1];
1834 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1835 uvmy = (my + ((my & 3) == 3)) >> 1;
1836 if (v->field_mode) {
1837 if (v->cur_field_type != v->ref_field_type[1])
1838 my = my - 2 + 4 * v->cur_field_type;
1839 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1842 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1843 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1845 srcY = s->next_picture.f.data[0];
1846 srcU = s->next_picture.f.data[1];
1847 srcV = s->next_picture.f.data[2];
1849 src_x = s->mb_x * 16 + (mx >> 2);
1850 src_y = s->mb_y * 16 + (my >> 2);
1851 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1852 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1854 if (v->profile != PROFILE_ADVANCED) {
1855 src_x = av_clip( src_x, -16, s->mb_width * 16);
1856 src_y = av_clip( src_y, -16, s->mb_height * 16);
1857 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1858 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1860 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1861 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1862 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1863 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1866 srcY += src_y * s->linesize + src_x;
1867 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1868 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1870 if (v->field_mode && v->ref_field_type[1]) {
1871 srcY += s->current_picture_ptr->f.linesize[0];
1872 srcU += s->current_picture_ptr->f.linesize[1];
1873 srcV += s->current_picture_ptr->f.linesize[2];
1876 /* for grayscale we should not try to read from unknown area */
1877 if (s->flags & CODEC_FLAG_GRAY) {
1878 srcU = s->edge_emu_buffer + 18 * s->linesize;
1879 srcV = s->edge_emu_buffer + 18 * s->linesize;
1882 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1883 || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1884 || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1885 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1887 srcY -= s->mspel * (1 + s->linesize);
1888 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1889 17 + s->mspel * 2, 17 + s->mspel * 2,
1890 src_x - s->mspel, src_y - s->mspel,
1891 s->h_edge_pos, v_edge_pos);
1892 srcY = s->edge_emu_buffer;
1893 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1894 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1895 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1896 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1899 /* if we deal with range reduction we need to scale source blocks */
1900 if (v->rangeredfrm) {
1902 uint8_t *src, *src2;
1905 for (j = 0; j < 17 + s->mspel * 2; j++) {
1906 for (i = 0; i < 17 + s->mspel * 2; i++)
1907 src[i] = ((src[i] - 128) >> 1) + 128;
1912 for (j = 0; j < 9; j++) {
1913 for (i = 0; i < 9; i++) {
1914 src[i] = ((src[i] - 128) >> 1) + 128;
1915 src2[i] = ((src2[i] - 128) >> 1) + 128;
1917 src += s->uvlinesize;
1918 src2 += s->uvlinesize;
1921 srcY += s->mspel * (1 + s->linesize);
1924 if (v->field_mode && v->cur_field_type) {
1925 off = s->current_picture_ptr->f.linesize[0];
1926 off_uv = s->current_picture_ptr->f.linesize[1];
1933 dxy = ((my & 3) << 2) | (mx & 3);
1934 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
1935 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1936 srcY += s->linesize * 8;
1937 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
1938 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1940 dxy = (my & 2) | ((mx & 2) >> 1);
1943 dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1945 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1948 if (s->flags & CODEC_FLAG_GRAY) return;
1949 /* Chroma MC always uses qpel blilinear */
1950 uvmx = (uvmx & 3) << 1;
1951 uvmy = (uvmy & 3) << 1;
1953 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1954 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1956 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1957 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1961 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1965 #if B_FRACTION_DEN==256
1969 return 2 * ((value * n + 255) >> 9);
1970 return (value * n + 128) >> 8;
1973 n -= B_FRACTION_DEN;
1975 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1976 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1980 /** Reconstruct motion vector for B-frame and do motion compensation
1982 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
1983 int direct, int mode)
1986 v->mv_mode2 = v->mv_mode;
1987 v->mv_mode = MV_PMODE_INTENSITY_COMP;
1993 v->mv_mode = v->mv_mode2;
1996 if (mode == BMV_TYPE_INTERPOLATED) {
2000 v->mv_mode = v->mv_mode2;
2004 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2005 v->mv_mode = v->mv_mode2;
2006 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2008 v->mv_mode = v->mv_mode2;
2011 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2012 int direct, int mvtype)
2014 MpegEncContext *s = &v->s;
2015 int xy, wrap, off = 0;
2020 const uint8_t *is_intra = v->mb_type[0];
2024 /* scale MV difference to be quad-pel */
2025 dmv_x[0] <<= 1 - s->quarter_sample;
2026 dmv_y[0] <<= 1 - s->quarter_sample;
2027 dmv_x[1] <<= 1 - s->quarter_sample;
2028 dmv_y[1] <<= 1 - s->quarter_sample;
2030 wrap = s->b8_stride;
2031 xy = s->block_index[0];
2034 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
2035 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
2036 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
2037 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
2040 if (!v->field_mode) {
2041 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2042 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2043 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2044 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2046 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2047 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));
2048 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));
2049 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));
2050 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));
2053 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2054 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2055 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2056 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2060 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2061 C = s->current_picture.f.motion_val[0][xy - 2];
2062 A = s->current_picture.f.motion_val[0][xy - wrap * 2];
2063 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2064 B = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
2066 if (!s->mb_x) C[0] = C[1] = 0;
2067 if (!s->first_slice_line) { // predictor A is not out of bounds
2068 if (s->mb_width == 1) {
2072 px = mid_pred(A[0], B[0], C[0]);
2073 py = mid_pred(A[1], B[1], C[1]);
2075 } else if (s->mb_x) { // predictor C is not out of bounds
2081 /* Pullback MV as specified in 8.3.5.3.4 */
2084 if (v->profile < PROFILE_ADVANCED) {
2085 qx = (s->mb_x << 5);
2086 qy = (s->mb_y << 5);
2087 X = (s->mb_width << 5) - 4;
2088 Y = (s->mb_height << 5) - 4;
2089 if (qx + px < -28) px = -28 - qx;
2090 if (qy + py < -28) py = -28 - qy;
2091 if (qx + px > X) px = X - qx;
2092 if (qy + py > Y) py = Y - qy;
2094 qx = (s->mb_x << 6);
2095 qy = (s->mb_y << 6);
2096 X = (s->mb_width << 6) - 4;
2097 Y = (s->mb_height << 6) - 4;
2098 if (qx + px < -60) px = -60 - qx;
2099 if (qy + py < -60) py = -60 - qy;
2100 if (qx + px > X) px = X - qx;
2101 if (qy + py > Y) py = Y - qy;
2104 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2105 if (0 && !s->first_slice_line && s->mb_x) {
2106 if (is_intra[xy - wrap])
2107 sum = FFABS(px) + FFABS(py);
2109 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2111 if (get_bits1(&s->gb)) {
2119 if (is_intra[xy - 2])
2120 sum = FFABS(px) + FFABS(py);
2122 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2124 if (get_bits1(&s->gb)) {
2134 /* store MV using signed modulus of MV range defined in 4.11 */
2135 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2136 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2138 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2139 C = s->current_picture.f.motion_val[1][xy - 2];
2140 A = s->current_picture.f.motion_val[1][xy - wrap * 2];
2141 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2142 B = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
2146 if (!s->first_slice_line) { // predictor A is not out of bounds
2147 if (s->mb_width == 1) {
2151 px = mid_pred(A[0], B[0], C[0]);
2152 py = mid_pred(A[1], B[1], C[1]);
2154 } else if (s->mb_x) { // predictor C is not out of bounds
2160 /* Pullback MV as specified in 8.3.5.3.4 */
2163 if (v->profile < PROFILE_ADVANCED) {
2164 qx = (s->mb_x << 5);
2165 qy = (s->mb_y << 5);
2166 X = (s->mb_width << 5) - 4;
2167 Y = (s->mb_height << 5) - 4;
2168 if (qx + px < -28) px = -28 - qx;
2169 if (qy + py < -28) py = -28 - qy;
2170 if (qx + px > X) px = X - qx;
2171 if (qy + py > Y) py = Y - qy;
2173 qx = (s->mb_x << 6);
2174 qy = (s->mb_y << 6);
2175 X = (s->mb_width << 6) - 4;
2176 Y = (s->mb_height << 6) - 4;
2177 if (qx + px < -60) px = -60 - qx;
2178 if (qy + py < -60) py = -60 - qy;
2179 if (qx + px > X) px = X - qx;
2180 if (qy + py > Y) py = Y - qy;
2183 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2184 if (0 && !s->first_slice_line && s->mb_x) {
2185 if (is_intra[xy - wrap])
2186 sum = FFABS(px) + FFABS(py);
2188 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2190 if (get_bits1(&s->gb)) {
2198 if (is_intra[xy - 2])
2199 sum = FFABS(px) + FFABS(py);
2201 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2203 if (get_bits1(&s->gb)) {
2213 /* store MV using signed modulus of MV range defined in 4.11 */
2215 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2216 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2218 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
2219 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
2220 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
2221 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
2224 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2226 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2227 MpegEncContext *s = &v->s;
2228 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2230 if (v->bmvtype == BMV_TYPE_DIRECT) {
2231 int total_opp, k, f;
2232 if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2233 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2234 v->bfraction, 0, s->quarter_sample);
2235 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2236 v->bfraction, 0, s->quarter_sample);
2237 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2238 v->bfraction, 1, s->quarter_sample);
2239 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2240 v->bfraction, 1, s->quarter_sample);
2242 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2243 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2244 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2245 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2246 f = (total_opp > 2) ? 1 : 0;
2248 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2249 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2252 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2253 for (k = 0; k < 4; k++) {
2254 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2255 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2256 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2257 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2258 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2259 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2263 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2264 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);
2265 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);
2268 if (dir) { // backward
2269 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);
2270 if (n == 3 || mv1) {
2271 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2274 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);
2275 if (n == 3 || mv1) {
2276 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2281 /** Get predicted DC value for I-frames only
2282 * prediction dir: left=0, top=1
2283 * @param s MpegEncContext
2284 * @param overlap flag indicating that overlap filtering is used
2285 * @param pq integer part of picture quantizer
2286 * @param[in] n block index in the current MB
2287 * @param dc_val_ptr Pointer to DC predictor
2288 * @param dir_ptr Prediction direction for use in AC prediction
2290 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2291 int16_t **dc_val_ptr, int *dir_ptr)
2293 int a, b, c, wrap, pred, scale;
2295 static const uint16_t dcpred[32] = {
2296 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2297 114, 102, 93, 85, 79, 73, 68, 64,
2298 60, 57, 54, 51, 49, 47, 45, 43,
2299 41, 39, 38, 37, 35, 34, 33
2302 /* find prediction - wmv3_dc_scale always used here in fact */
2303 if (n < 4) scale = s->y_dc_scale;
2304 else scale = s->c_dc_scale;
2306 wrap = s->block_wrap[n];
2307 dc_val = s->dc_val[0] + s->block_index[n];
2313 b = dc_val[ - 1 - wrap];
2314 a = dc_val[ - wrap];
2316 if (pq < 9 || !overlap) {
2317 /* Set outer values */
2318 if (s->first_slice_line && (n != 2 && n != 3))
2319 b = a = dcpred[scale];
2320 if (s->mb_x == 0 && (n != 1 && n != 3))
2321 b = c = dcpred[scale];
2323 /* Set outer values */
2324 if (s->first_slice_line && (n != 2 && n != 3))
2326 if (s->mb_x == 0 && (n != 1 && n != 3))
2330 if (abs(a - b) <= abs(b - c)) {
2332 *dir_ptr = 1; // left
2335 *dir_ptr = 0; // top
2338 /* update predictor */
2339 *dc_val_ptr = &dc_val[0];
2344 /** Get predicted DC value
2345 * prediction dir: left=0, top=1
2346 * @param s MpegEncContext
2347 * @param overlap flag indicating that overlap filtering is used
2348 * @param pq integer part of picture quantizer
2349 * @param[in] n block index in the current MB
2350 * @param a_avail flag indicating top block availability
2351 * @param c_avail flag indicating left block availability
2352 * @param dc_val_ptr Pointer to DC predictor
2353 * @param dir_ptr Prediction direction for use in AC prediction
2355 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2356 int a_avail, int c_avail,
2357 int16_t **dc_val_ptr, int *dir_ptr)
2359 int a, b, c, wrap, pred;
2361 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2365 wrap = s->block_wrap[n];
2366 dc_val = s->dc_val[0] + s->block_index[n];
2372 b = dc_val[ - 1 - wrap];
2373 a = dc_val[ - wrap];
2374 /* scale predictors if needed */
2375 q1 = s->current_picture.f.qscale_table[mb_pos];
2376 dqscale_index = s->y_dc_scale_table[q1] - 1;
2377 if (dqscale_index < 0)
2379 if (c_avail && (n != 1 && n != 3)) {
2380 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2382 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2384 if (a_avail && (n != 2 && n != 3)) {
2385 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2387 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2389 if (a_avail && c_avail && (n != 3)) {
2394 off -= s->mb_stride;
2395 q2 = s->current_picture.f.qscale_table[off];
2397 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2400 if (a_avail && c_avail) {
2401 if (abs(a - b) <= abs(b - c)) {
2403 *dir_ptr = 1; // left
2406 *dir_ptr = 0; // top
2408 } else if (a_avail) {
2410 *dir_ptr = 0; // top
2411 } else if (c_avail) {
2413 *dir_ptr = 1; // left
2416 *dir_ptr = 1; // left
2419 /* update predictor */
2420 *dc_val_ptr = &dc_val[0];
2424 /** @} */ // Block group
2427 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2428 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2432 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2433 uint8_t **coded_block_ptr)
2435 int xy, wrap, pred, a, b, c;
2437 xy = s->block_index[n];
2438 wrap = s->b8_stride;
2443 a = s->coded_block[xy - 1 ];
2444 b = s->coded_block[xy - 1 - wrap];
2445 c = s->coded_block[xy - wrap];
2454 *coded_block_ptr = &s->coded_block[xy];
2460 * Decode one AC coefficient
2461 * @param v The VC1 context
2462 * @param last Last coefficient
2463 * @param skip How much zero coefficients to skip
2464 * @param value Decoded AC coefficient value
2465 * @param codingset set of VLC to decode data
2468 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2469 int *value, int codingset)
2471 GetBitContext *gb = &v->s.gb;
2472 int index, escape, run = 0, level = 0, lst = 0;
2474 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2475 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2476 run = vc1_index_decode_table[codingset][index][0];
2477 level = vc1_index_decode_table[codingset][index][1];
2478 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2482 escape = decode210(gb);
2484 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
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];
2490 level += vc1_last_delta_level_table[codingset][run];
2492 level += vc1_delta_level_table[codingset][run];
2495 run += vc1_last_delta_run_table[codingset][level] + 1;
2497 run += vc1_delta_run_table[codingset][level] + 1;
2503 lst = get_bits1(gb);
2504 if (v->s.esc3_level_length == 0) {
2505 if (v->pq < 8 || v->dquantfrm) { // table 59
2506 v->s.esc3_level_length = get_bits(gb, 3);
2507 if (!v->s.esc3_level_length)
2508 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2509 } else { // table 60
2510 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2512 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2514 run = get_bits(gb, v->s.esc3_run_length);
2515 sign = get_bits1(gb);
2516 level = get_bits(gb, v->s.esc3_level_length);
2527 /** Decode intra block in intra frames - should be faster than decode_intra_block
2528 * @param v VC1Context
2529 * @param block block to decode
2530 * @param[in] n subblock index
2531 * @param coded are AC coeffs present or not
2532 * @param codingset set of VLC to decode data
2534 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
2535 int coded, int codingset)
2537 GetBitContext *gb = &v->s.gb;
2538 MpegEncContext *s = &v->s;
2539 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2542 int16_t *ac_val, *ac_val2;
2545 /* Get DC differential */
2547 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2549 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2552 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2556 if (dcdiff == 119 /* ESC index value */) {
2557 /* TODO: Optimize */
2558 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2559 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2560 else dcdiff = get_bits(gb, 8);
2563 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2564 else if (v->pq == 2)
2565 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2572 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2575 /* Store the quantized DC coeff, used for prediction */
2577 block[0] = dcdiff * s->y_dc_scale;
2579 block[0] = dcdiff * s->c_dc_scale;
2590 int last = 0, skip, value;
2591 const uint8_t *zz_table;
2595 scale = v->pq * 2 + v->halfpq;
2599 zz_table = v->zz_8x8[2];
2601 zz_table = v->zz_8x8[3];
2603 zz_table = v->zz_8x8[1];
2605 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2607 if (dc_pred_dir) // left
2610 ac_val -= 16 * s->block_wrap[n];
2613 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2617 block[zz_table[i++]] = value;
2620 /* apply AC prediction if needed */
2622 if (dc_pred_dir) { // left
2623 for (k = 1; k < 8; k++)
2624 block[k << v->left_blk_sh] += ac_val[k];
2626 for (k = 1; k < 8; k++)
2627 block[k << v->top_blk_sh] += ac_val[k + 8];
2630 /* save AC coeffs for further prediction */
2631 for (k = 1; k < 8; k++) {
2632 ac_val2[k] = block[k << v->left_blk_sh];
2633 ac_val2[k + 8] = block[k << v->top_blk_sh];
2636 /* scale AC coeffs */
2637 for (k = 1; k < 64; k++)
2641 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2644 if (s->ac_pred) i = 63;
2650 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2654 scale = v->pq * 2 + v->halfpq;
2655 memset(ac_val2, 0, 16 * 2);
2656 if (dc_pred_dir) { // left
2659 memcpy(ac_val2, ac_val, 8 * 2);
2661 ac_val -= 16 * s->block_wrap[n];
2663 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2666 /* apply AC prediction if needed */
2668 if (dc_pred_dir) { //left
2669 for (k = 1; k < 8; k++) {
2670 block[k << v->left_blk_sh] = ac_val[k] * scale;
2671 if (!v->pquantizer && block[k << v->left_blk_sh])
2672 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2675 for (k = 1; k < 8; k++) {
2676 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2677 if (!v->pquantizer && block[k << v->top_blk_sh])
2678 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2684 s->block_last_index[n] = i;
2689 /** Decode intra block in intra frames - should be faster than decode_intra_block
2690 * @param v VC1Context
2691 * @param block block to decode
2692 * @param[in] n subblock number
2693 * @param coded are AC coeffs present or not
2694 * @param codingset set of VLC to decode data
2695 * @param mquant quantizer value for this macroblock
2697 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
2698 int coded, int codingset, int mquant)
2700 GetBitContext *gb = &v->s.gb;
2701 MpegEncContext *s = &v->s;
2702 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2705 int16_t *ac_val, *ac_val2;
2707 int a_avail = v->a_avail, c_avail = v->c_avail;
2708 int use_pred = s->ac_pred;
2711 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2713 /* Get DC differential */
2715 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2717 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2720 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2724 if (dcdiff == 119 /* ESC index value */) {
2725 /* TODO: Optimize */
2726 if (mquant == 1) dcdiff = get_bits(gb, 10);
2727 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2728 else dcdiff = get_bits(gb, 8);
2731 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2732 else if (mquant == 2)
2733 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2740 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2743 /* Store the quantized DC coeff, used for prediction */
2745 block[0] = dcdiff * s->y_dc_scale;
2747 block[0] = dcdiff * s->c_dc_scale;
2753 /* check if AC is needed at all */
2754 if (!a_avail && !c_avail)
2756 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2759 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2761 if (dc_pred_dir) // left
2764 ac_val -= 16 * s->block_wrap[n];
2766 q1 = s->current_picture.f.qscale_table[mb_pos];
2767 if ( dc_pred_dir && c_avail && mb_pos)
2768 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2769 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2770 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2771 if ( dc_pred_dir && n == 1)
2773 if (!dc_pred_dir && n == 2)
2779 int last = 0, skip, value;
2780 const uint8_t *zz_table;
2784 if (!use_pred && v->fcm == ILACE_FRAME) {
2785 zz_table = v->zzi_8x8;
2787 if (!dc_pred_dir) // top
2788 zz_table = v->zz_8x8[2];
2790 zz_table = v->zz_8x8[3];
2793 if (v->fcm != ILACE_FRAME)
2794 zz_table = v->zz_8x8[1];
2796 zz_table = v->zzi_8x8;
2800 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2804 block[zz_table[i++]] = value;
2807 /* apply AC prediction if needed */
2809 /* scale predictors if needed*/
2810 if (q2 && q1 != q2) {
2811 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2812 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2815 return AVERROR_INVALIDDATA;
2816 if (dc_pred_dir) { // left
2817 for (k = 1; k < 8; k++)
2818 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2820 for (k = 1; k < 8; k++)
2821 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2824 if (dc_pred_dir) { //left
2825 for (k = 1; k < 8; k++)
2826 block[k << v->left_blk_sh] += ac_val[k];
2828 for (k = 1; k < 8; k++)
2829 block[k << v->top_blk_sh] += ac_val[k + 8];
2833 /* save AC coeffs for further prediction */
2834 for (k = 1; k < 8; k++) {
2835 ac_val2[k ] = block[k << v->left_blk_sh];
2836 ac_val2[k + 8] = block[k << v->top_blk_sh];
2839 /* scale AC coeffs */
2840 for (k = 1; k < 64; k++)
2844 block[k] += (block[k] < 0) ? -mquant : mquant;
2847 if (use_pred) i = 63;
2848 } else { // no AC coeffs
2851 memset(ac_val2, 0, 16 * 2);
2852 if (dc_pred_dir) { // left
2854 memcpy(ac_val2, ac_val, 8 * 2);
2855 if (q2 && q1 != q2) {
2856 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2857 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2859 return AVERROR_INVALIDDATA;
2860 for (k = 1; k < 8; k++)
2861 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2866 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2867 if (q2 && q1 != q2) {
2868 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2869 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2871 return AVERROR_INVALIDDATA;
2872 for (k = 1; k < 8; k++)
2873 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2878 /* apply AC prediction if needed */
2880 if (dc_pred_dir) { // left
2881 for (k = 1; k < 8; k++) {
2882 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2883 if (!v->pquantizer && block[k << v->left_blk_sh])
2884 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2887 for (k = 1; k < 8; k++) {
2888 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2889 if (!v->pquantizer && block[k << v->top_blk_sh])
2890 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2896 s->block_last_index[n] = i;
2901 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2902 * @param v VC1Context
2903 * @param block block to decode
2904 * @param[in] n subblock index
2905 * @param coded are AC coeffs present or not
2906 * @param mquant block quantizer
2907 * @param codingset set of VLC to decode data
2909 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
2910 int coded, int mquant, int codingset)
2912 GetBitContext *gb = &v->s.gb;
2913 MpegEncContext *s = &v->s;
2914 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2917 int16_t *ac_val, *ac_val2;
2919 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2920 int a_avail = v->a_avail, c_avail = v->c_avail;
2921 int use_pred = s->ac_pred;
2925 s->dsp.clear_block(block);
2927 /* XXX: Guard against dumb values of mquant */
2928 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2930 /* Set DC scale - y and c use the same */
2931 s->y_dc_scale = s->y_dc_scale_table[mquant];
2932 s->c_dc_scale = s->c_dc_scale_table[mquant];
2934 /* Get DC differential */
2936 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2938 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2941 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2945 if (dcdiff == 119 /* ESC index value */) {
2946 /* TODO: Optimize */
2947 if (mquant == 1) dcdiff = get_bits(gb, 10);
2948 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2949 else dcdiff = get_bits(gb, 8);
2952 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2953 else if (mquant == 2)
2954 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2961 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2964 /* Store the quantized DC coeff, used for prediction */
2967 block[0] = dcdiff * s->y_dc_scale;
2969 block[0] = dcdiff * s->c_dc_scale;
2975 /* check if AC is needed at all and adjust direction if needed */
2976 if (!a_avail) dc_pred_dir = 1;
2977 if (!c_avail) dc_pred_dir = 0;
2978 if (!a_avail && !c_avail) use_pred = 0;
2979 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2982 scale = mquant * 2 + v->halfpq;
2984 if (dc_pred_dir) //left
2987 ac_val -= 16 * s->block_wrap[n];
2989 q1 = s->current_picture.f.qscale_table[mb_pos];
2990 if (dc_pred_dir && c_avail && mb_pos)
2991 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2992 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2993 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2994 if ( dc_pred_dir && n == 1)
2996 if (!dc_pred_dir && n == 2)
2998 if (n == 3) q2 = q1;
3001 int last = 0, skip, value;
3005 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3009 if (v->fcm == PROGRESSIVE)
3010 block[v->zz_8x8[0][i++]] = value;
3012 if (use_pred && (v->fcm == ILACE_FRAME)) {
3013 if (!dc_pred_dir) // top
3014 block[v->zz_8x8[2][i++]] = value;
3016 block[v->zz_8x8[3][i++]] = value;
3018 block[v->zzi_8x8[i++]] = value;
3023 /* apply AC prediction if needed */
3025 /* scale predictors if needed*/
3026 if (q2 && q1 != q2) {
3027 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3028 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3031 return AVERROR_INVALIDDATA;
3032 if (dc_pred_dir) { // left
3033 for (k = 1; k < 8; k++)
3034 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3036 for (k = 1; k < 8; k++)
3037 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3040 if (dc_pred_dir) { // left
3041 for (k = 1; k < 8; k++)
3042 block[k << v->left_blk_sh] += ac_val[k];
3044 for (k = 1; k < 8; k++)
3045 block[k << v->top_blk_sh] += ac_val[k + 8];
3049 /* save AC coeffs for further prediction */
3050 for (k = 1; k < 8; k++) {
3051 ac_val2[k ] = block[k << v->left_blk_sh];
3052 ac_val2[k + 8] = block[k << v->top_blk_sh];
3055 /* scale AC coeffs */
3056 for (k = 1; k < 64; k++)
3060 block[k] += (block[k] < 0) ? -mquant : mquant;
3063 if (use_pred) i = 63;
3064 } else { // no AC coeffs
3067 memset(ac_val2, 0, 16 * 2);
3068 if (dc_pred_dir) { // left
3070 memcpy(ac_val2, ac_val, 8 * 2);
3071 if (q2 && q1 != q2) {
3072 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3073 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3075 return AVERROR_INVALIDDATA;
3076 for (k = 1; k < 8; k++)
3077 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3082 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3083 if (q2 && q1 != q2) {
3084 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3085 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3087 return AVERROR_INVALIDDATA;
3088 for (k = 1; k < 8; k++)
3089 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3094 /* apply AC prediction if needed */
3096 if (dc_pred_dir) { // left
3097 for (k = 1; k < 8; k++) {
3098 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3099 if (!v->pquantizer && block[k << v->left_blk_sh])
3100 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3103 for (k = 1; k < 8; k++) {
3104 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3105 if (!v->pquantizer && block[k << v->top_blk_sh])
3106 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3112 s->block_last_index[n] = i;
3119 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
3120 int mquant, int ttmb, int first_block,
3121 uint8_t *dst, int linesize, int skip_block,
3124 MpegEncContext *s = &v->s;
3125 GetBitContext *gb = &s->gb;
3128 int scale, off, idx, last, skip, value;
3129 int ttblk = ttmb & 7;
3132 s->dsp.clear_block(block);
3135 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)];
3137 if (ttblk == TT_4X4) {
3138 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3140 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3141 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3142 || (!v->res_rtm_flag && !first_block))) {
3143 subblkpat = decode012(gb);
3145 subblkpat ^= 3; // swap decoded pattern bits
3146 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3148 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3151 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3153 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3154 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3155 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3158 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3159 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3168 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3173 idx = v->zz_8x8[0][i++];
3175 idx = v->zzi_8x8[i++];
3176 block[idx] = value * scale;
3178 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3182 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3184 v->vc1dsp.vc1_inv_trans_8x8(block);
3185 s->dsp.add_pixels_clamped(block, dst, linesize);
3190 pat = ~subblkpat & 0xF;
3191 for (j = 0; j < 4; j++) {
3192 last = subblkpat & (1 << (3 - j));
3194 off = (j & 1) * 4 + (j & 2) * 16;
3196 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3201 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3203 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3204 block[idx + off] = value * scale;
3206 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3208 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3210 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3212 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3217 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3218 for (j = 0; j < 2; j++) {
3219 last = subblkpat & (1 << (1 - j));
3223 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3228 idx = v->zz_8x4[i++] + off;
3230 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3231 block[idx] = value * scale;
3233 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3235 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3237 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3239 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3244 pat = ~(subblkpat * 5) & 0xF;
3245 for (j = 0; j < 2; j++) {
3246 last = subblkpat & (1 << (1 - j));
3250 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3255 idx = v->zz_4x8[i++] + off;
3257 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3258 block[idx] = value * scale;
3260 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3262 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3264 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3266 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3272 *ttmb_out |= ttblk << (n * 4);
3276 /** @} */ // Macroblock group
3278 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3279 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3281 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3283 MpegEncContext *s = &v->s;
3284 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3285 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3286 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3287 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3288 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3291 if (block_num > 3) {
3292 dst = s->dest[block_num - 3];
3294 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3296 if (s->mb_y != s->end_mb_y || block_num < 2) {
3300 if (block_num > 3) {
3301 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3302 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3303 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3304 mv_stride = s->mb_stride;
3306 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3307 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3308 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3309 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3310 mv_stride = s->b8_stride;
3311 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3314 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3315 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3316 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3318 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3320 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3323 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3325 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3330 dst -= 4 * linesize;
3331 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3332 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3333 idx = (block_cbp | (block_cbp >> 2)) & 3;
3335 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3338 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3340 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3345 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3347 MpegEncContext *s = &v->s;
3348 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3349 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3350 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3351 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3352 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3355 if (block_num > 3) {
3356 dst = s->dest[block_num - 3] - 8 * linesize;
3358 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3361 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3364 if (block_num > 3) {
3365 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3366 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3367 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3369 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3370 : (mb_cbp >> ((block_num + 1) * 4));
3371 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3372 : (mb_is_intra >> ((block_num + 1) * 4));
3373 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3375 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3376 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3378 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3380 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3383 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3385 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3391 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3392 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3393 idx = (block_cbp | (block_cbp >> 1)) & 5;
3395 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3398 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3400 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3405 static void vc1_apply_p_loop_filter(VC1Context *v)
3407 MpegEncContext *s = &v->s;
3410 for (i = 0; i < 6; i++) {
3411 vc1_apply_p_v_loop_filter(v, i);
3414 /* V always precedes H, therefore we run H one MB before V;
3415 * at the end of a row, we catch up to complete the row */
3417 for (i = 0; i < 6; i++) {
3418 vc1_apply_p_h_loop_filter(v, i);
3420 if (s->mb_x == s->mb_width - 1) {
3422 ff_update_block_index(s);
3423 for (i = 0; i < 6; i++) {
3424 vc1_apply_p_h_loop_filter(v, i);
3430 /** Decode one P-frame MB
3432 static int vc1_decode_p_mb(VC1Context *v)
3434 MpegEncContext *s = &v->s;
3435 GetBitContext *gb = &s->gb;
3437 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3438 int cbp; /* cbp decoding stuff */
3439 int mqdiff, mquant; /* MB quantization */
3440 int ttmb = v->ttfrm; /* MB Transform type */
3442 int mb_has_coeffs = 1; /* last_flag */
3443 int dmv_x, dmv_y; /* Differential MV components */
3444 int index, index1; /* LUT indexes */
3445 int val, sign; /* temp values */
3446 int first_block = 1;
3448 int skipped, fourmv;
3449 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3451 mquant = v->pq; /* lossy initialization */
3453 if (v->mv_type_is_raw)
3454 fourmv = get_bits1(gb);
3456 fourmv = v->mv_type_mb_plane[mb_pos];
3458 skipped = get_bits1(gb);
3460 skipped = v->s.mbskip_table[mb_pos];
3462 if (!fourmv) { /* 1MV mode */
3464 GET_MVDATA(dmv_x, dmv_y);
3467 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3468 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3470 s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3471 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3473 /* FIXME Set DC val for inter block ? */
3474 if (s->mb_intra && !mb_has_coeffs) {
3476 s->ac_pred = get_bits1(gb);
3478 } else if (mb_has_coeffs) {
3480 s->ac_pred = get_bits1(gb);
3481 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3487 s->current_picture.f.qscale_table[mb_pos] = mquant;
3489 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3490 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3491 VC1_TTMB_VLC_BITS, 2);
3492 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3494 for (i = 0; i < 6; i++) {
3495 s->dc_val[0][s->block_index[i]] = 0;
3497 val = ((cbp >> (5 - i)) & 1);
3498 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3499 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3501 /* check if prediction blocks A and C are available */
3502 v->a_avail = v->c_avail = 0;
3503 if (i == 2 || i == 3 || !s->first_slice_line)
3504 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3505 if (i == 1 || i == 3 || s->mb_x)
3506 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3508 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3509 (i & 4) ? v->codingset2 : v->codingset);
3510 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3512 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3514 for (j = 0; j < 64; j++)
3515 s->block[i][j] <<= 1;
3516 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3517 if (v->pq >= 9 && v->overlap) {
3519 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3521 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3523 block_cbp |= 0xF << (i << 2);
3524 block_intra |= 1 << i;
3526 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3527 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3528 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3529 block_cbp |= pat << (i << 2);
3530 if (!v->ttmbf && ttmb < 8)
3537 for (i = 0; i < 6; i++) {
3538 v->mb_type[0][s->block_index[i]] = 0;
3539 s->dc_val[0][s->block_index[i]] = 0;
3541 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3542 s->current_picture.f.qscale_table[mb_pos] = 0;
3543 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3546 } else { // 4MV mode
3547 if (!skipped /* unskipped MB */) {
3548 int intra_count = 0, coded_inter = 0;
3549 int is_intra[6], is_coded[6];
3551 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3552 for (i = 0; i < 6; i++) {
3553 val = ((cbp >> (5 - i)) & 1);
3554 s->dc_val[0][s->block_index[i]] = 0;
3561 GET_MVDATA(dmv_x, dmv_y);
3563 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3565 vc1_mc_4mv_luma(v, i, 0);
3566 intra_count += s->mb_intra;
3567 is_intra[i] = s->mb_intra;
3568 is_coded[i] = mb_has_coeffs;
3571 is_intra[i] = (intra_count >= 3);
3575 vc1_mc_4mv_chroma(v, 0);
3576 v->mb_type[0][s->block_index[i]] = is_intra[i];
3578 coded_inter = !is_intra[i] & is_coded[i];
3580 // if there are no coded blocks then don't do anything more
3582 if (!intra_count && !coded_inter)
3585 s->current_picture.f.qscale_table[mb_pos] = mquant;
3586 /* test if block is intra and has pred */
3589 for (i = 0; i < 6; i++)
3591 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3592 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3598 s->ac_pred = get_bits1(gb);
3602 if (!v->ttmbf && coded_inter)
3603 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3604 for (i = 0; i < 6; i++) {
3606 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3607 s->mb_intra = is_intra[i];
3609 /* check if prediction blocks A and C are available */
3610 v->a_avail = v->c_avail = 0;
3611 if (i == 2 || i == 3 || !s->first_slice_line)
3612 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3613 if (i == 1 || i == 3 || s->mb_x)
3614 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3616 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3617 (i & 4) ? v->codingset2 : v->codingset);
3618 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3620 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3622 for (j = 0; j < 64; j++)
3623 s->block[i][j] <<= 1;
3624 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3625 (i & 4) ? s->uvlinesize : s->linesize);
3626 if (v->pq >= 9 && v->overlap) {
3628 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3630 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3632 block_cbp |= 0xF << (i << 2);
3633 block_intra |= 1 << i;
3634 } else if (is_coded[i]) {
3635 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3636 first_block, s->dest[dst_idx] + off,
3637 (i & 4) ? s->uvlinesize : s->linesize,
3638 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3640 block_cbp |= pat << (i << 2);
3641 if (!v->ttmbf && ttmb < 8)
3646 } else { // skipped MB
3648 s->current_picture.f.qscale_table[mb_pos] = 0;
3649 for (i = 0; i < 6; i++) {
3650 v->mb_type[0][s->block_index[i]] = 0;
3651 s->dc_val[0][s->block_index[i]] = 0;
3653 for (i = 0; i < 4; i++) {
3654 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3655 vc1_mc_4mv_luma(v, i, 0);
3657 vc1_mc_4mv_chroma(v, 0);
3658 s->current_picture.f.qscale_table[mb_pos] = 0;
3662 v->cbp[s->mb_x] = block_cbp;
3663 v->ttblk[s->mb_x] = block_tt;
3664 v->is_intra[s->mb_x] = block_intra;
3669 /* Decode one macroblock in an interlaced frame p picture */
3671 static int vc1_decode_p_mb_intfr(VC1Context *v)
3673 MpegEncContext *s = &v->s;
3674 GetBitContext *gb = &s->gb;
3676 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3677 int cbp = 0; /* cbp decoding stuff */
3678 int mqdiff, mquant; /* MB quantization */
3679 int ttmb = v->ttfrm; /* MB Transform type */
3681 int mb_has_coeffs = 1; /* last_flag */
3682 int dmv_x, dmv_y; /* Differential MV components */
3683 int val; /* temp value */
3684 int first_block = 1;
3686 int skipped, fourmv = 0, twomv = 0;
3687 int block_cbp = 0, pat, block_tt = 0;
3688 int idx_mbmode = 0, mvbp;
3689 int stride_y, fieldtx;
3691 mquant = v->pq; /* Loosy initialization */
3694 skipped = get_bits1(gb);
3696 skipped = v->s.mbskip_table[mb_pos];
3698 if (v->fourmvswitch)
3699 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3701 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3702 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3703 /* store the motion vector type in a flag (useful later) */
3704 case MV_PMODE_INTFR_4MV:
3706 v->blk_mv_type[s->block_index[0]] = 0;
3707 v->blk_mv_type[s->block_index[1]] = 0;
3708 v->blk_mv_type[s->block_index[2]] = 0;
3709 v->blk_mv_type[s->block_index[3]] = 0;
3711 case MV_PMODE_INTFR_4MV_FIELD:
3713 v->blk_mv_type[s->block_index[0]] = 1;
3714 v->blk_mv_type[s->block_index[1]] = 1;
3715 v->blk_mv_type[s->block_index[2]] = 1;
3716 v->blk_mv_type[s->block_index[3]] = 1;
3718 case MV_PMODE_INTFR_2MV_FIELD:
3720 v->blk_mv_type[s->block_index[0]] = 1;
3721 v->blk_mv_type[s->block_index[1]] = 1;
3722 v->blk_mv_type[s->block_index[2]] = 1;
3723 v->blk_mv_type[s->block_index[3]] = 1;
3725 case MV_PMODE_INTFR_1MV:
3726 v->blk_mv_type[s->block_index[0]] = 0;
3727 v->blk_mv_type[s->block_index[1]] = 0;
3728 v->blk_mv_type[s->block_index[2]] = 0;
3729 v->blk_mv_type[s->block_index[3]] = 0;
3732 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3733 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3734 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3735 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
3736 s->mb_intra = v->is_intra[s->mb_x] = 1;
3737 for (i = 0; i < 6; i++)
3738 v->mb_type[0][s->block_index[i]] = 1;
3739 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3740 mb_has_coeffs = get_bits1(gb);
3742 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3743 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3745 s->current_picture.f.qscale_table[mb_pos] = mquant;
3746 /* Set DC scale - y and c use the same (not sure if necessary here) */
3747 s->y_dc_scale = s->y_dc_scale_table[mquant];
3748 s->c_dc_scale = s->c_dc_scale_table[mquant];
3750 for (i = 0; i < 6; i++) {
3751 s->dc_val[0][s->block_index[i]] = 0;
3753 val = ((cbp >> (5 - i)) & 1);
3754 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3755 v->a_avail = v->c_avail = 0;
3756 if (i == 2 || i == 3 || !s->first_slice_line)
3757 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3758 if (i == 1 || i == 3 || s->mb_x)
3759 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3761 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3762 (i & 4) ? v->codingset2 : v->codingset);
3763 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3764 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3766 stride_y = s->linesize << fieldtx;
3767 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3769 stride_y = s->uvlinesize;
3772 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3776 } else { // inter MB
3777 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3779 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3780 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3781 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3783 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3784 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3785 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3788 s->mb_intra = v->is_intra[s->mb_x] = 0;
3789 for (i = 0; i < 6; i++)
3790 v->mb_type[0][s->block_index[i]] = 0;
3791 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3792 /* for all motion vector read MVDATA and motion compensate each block */
3796 for (i = 0; i < 6; i++) {
3799 val = ((mvbp >> (3 - i)) & 1);
3801 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3803 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3804 vc1_mc_4mv_luma(v, i, 0);
3805 } else if (i == 4) {
3806 vc1_mc_4mv_chroma4(v);
3813 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3815 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3816 vc1_mc_4mv_luma(v, 0, 0);
3817 vc1_mc_4mv_luma(v, 1, 0);
3820 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3822 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3823 vc1_mc_4mv_luma(v, 2, 0);
3824 vc1_mc_4mv_luma(v, 3, 0);
3825 vc1_mc_4mv_chroma4(v);
3827 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3830 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3832 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3836 GET_MQUANT(); // p. 227
3837 s->current_picture.f.qscale_table[mb_pos] = mquant;
3838 if (!v->ttmbf && cbp)
3839 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3840 for (i = 0; i < 6; i++) {
3841 s->dc_val[0][s->block_index[i]] = 0;
3843 val = ((cbp >> (5 - i)) & 1);
3845 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3847 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3849 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3850 first_block, s->dest[dst_idx] + off,
3851 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3852 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3853 block_cbp |= pat << (i << 2);
3854 if (!v->ttmbf && ttmb < 8)
3861 s->mb_intra = v->is_intra[s->mb_x] = 0;
3862 for (i = 0; i < 6; i++) {
3863 v->mb_type[0][s->block_index[i]] = 0;
3864 s->dc_val[0][s->block_index[i]] = 0;
3866 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3867 s->current_picture.f.qscale_table[mb_pos] = 0;
3868 v->blk_mv_type[s->block_index[0]] = 0;
3869 v->blk_mv_type[s->block_index[1]] = 0;
3870 v->blk_mv_type[s->block_index[2]] = 0;
3871 v->blk_mv_type[s->block_index[3]] = 0;
3872 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3875 if (s->mb_x == s->mb_width - 1)
3876 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3880 static int vc1_decode_p_mb_intfi(VC1Context *v)
3882 MpegEncContext *s = &v->s;
3883 GetBitContext *gb = &s->gb;
3885 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3886 int cbp = 0; /* cbp decoding stuff */
3887 int mqdiff, mquant; /* MB quantization */
3888 int ttmb = v->ttfrm; /* MB Transform type */
3890 int mb_has_coeffs = 1; /* last_flag */
3891 int dmv_x, dmv_y; /* Differential MV components */
3892 int val; /* temp values */
3893 int first_block = 1;
3896 int block_cbp = 0, pat, block_tt = 0;
3899 mquant = v->pq; /* Loosy initialization */
3901 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3902 if (idx_mbmode <= 1) { // intra MB
3903 s->mb_intra = v->is_intra[s->mb_x] = 1;
3904 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3905 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3906 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3908 s->current_picture.f.qscale_table[mb_pos] = mquant;
3909 /* Set DC scale - y and c use the same (not sure if necessary here) */
3910 s->y_dc_scale = s->y_dc_scale_table[mquant];
3911 s->c_dc_scale = s->c_dc_scale_table[mquant];
3912 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3913 mb_has_coeffs = idx_mbmode & 1;
3915 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3917 for (i = 0; i < 6; i++) {
3918 s->dc_val[0][s->block_index[i]] = 0;
3919 v->mb_type[0][s->block_index[i]] = 1;
3921 val = ((cbp >> (5 - i)) & 1);
3922 v->a_avail = v->c_avail = 0;
3923 if (i == 2 || i == 3 || !s->first_slice_line)
3924 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3925 if (i == 1 || i == 3 || s->mb_x)
3926 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3928 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3929 (i & 4) ? v->codingset2 : v->codingset);
3930 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3932 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3933 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3934 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
3935 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
3936 // TODO: loop filter
3939 s->mb_intra = v->is_intra[s->mb_x] = 0;
3940 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3941 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3942 if (idx_mbmode <= 5) { // 1-MV
3943 dmv_x = dmv_y = pred_flag = 0;
3944 if (idx_mbmode & 1) {
3945 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3947 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3949 mb_has_coeffs = !(idx_mbmode & 2);
3951 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3952 for (i = 0; i < 6; i++) {
3954 dmv_x = dmv_y = pred_flag = 0;
3955 val = ((v->fourmvbp >> (3 - i)) & 1);
3957 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3959 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3960 vc1_mc_4mv_luma(v, i, 0);
3962 vc1_mc_4mv_chroma(v, 0);
3964 mb_has_coeffs = idx_mbmode & 1;
3967 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3971 s->current_picture.f.qscale_table[mb_pos] = mquant;
3972 if (!v->ttmbf && cbp) {
3973 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3976 for (i = 0; i < 6; i++) {
3977 s->dc_val[0][s->block_index[i]] = 0;
3979 val = ((cbp >> (5 - i)) & 1);
3980 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
3981 if (v->cur_field_type)
3982 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
3984 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3985 first_block, s->dest[dst_idx] + off,
3986 (i & 4) ? s->uvlinesize : s->linesize,
3987 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3989 block_cbp |= pat << (i << 2);
3990 if (!v->ttmbf && ttmb < 8) ttmb = -1;
3995 if (s->mb_x == s->mb_width - 1)
3996 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4000 /** Decode one B-frame MB (in Main profile)
4002 static void vc1_decode_b_mb(VC1Context *v)
4004 MpegEncContext *s = &v->s;
4005 GetBitContext *gb = &s->gb;
4007 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4008 int cbp = 0; /* cbp decoding stuff */
4009 int mqdiff, mquant; /* MB quantization */
4010 int ttmb = v->ttfrm; /* MB Transform type */
4011 int mb_has_coeffs = 0; /* last_flag */
4012 int index, index1; /* LUT indexes */
4013 int val, sign; /* temp values */
4014 int first_block = 1;
4016 int skipped, direct;
4017 int dmv_x[2], dmv_y[2];
4018 int bmvtype = BMV_TYPE_BACKWARD;
4020 mquant = v->pq; /* lossy initialization */
4024 direct = get_bits1(gb);
4026 direct = v->direct_mb_plane[mb_pos];
4028 skipped = get_bits1(gb);
4030 skipped = v->s.mbskip_table[mb_pos];
4032 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4033 for (i = 0; i < 6; i++) {
4034 v->mb_type[0][s->block_index[i]] = 0;
4035 s->dc_val[0][s->block_index[i]] = 0;
4037 s->current_picture.f.qscale_table[mb_pos] = 0;
4041 GET_MVDATA(dmv_x[0], dmv_y[0]);
4042 dmv_x[1] = dmv_x[0];
4043 dmv_y[1] = dmv_y[0];
4045 if (skipped || !s->mb_intra) {
4046 bmvtype = decode012(gb);
4049 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4052 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4055 bmvtype = BMV_TYPE_INTERPOLATED;
4056 dmv_x[0] = dmv_y[0] = 0;
4060 for (i = 0; i < 6; i++)
4061 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4065 bmvtype = BMV_TYPE_INTERPOLATED;
4066 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4067 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4071 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4074 s->current_picture.f.qscale_table[mb_pos] = mquant;
4076 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4077 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4078 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4079 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4081 if (!mb_has_coeffs && !s->mb_intra) {
4082 /* no coded blocks - effectively skipped */
4083 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4084 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4087 if (s->mb_intra && !mb_has_coeffs) {
4089 s->current_picture.f.qscale_table[mb_pos] = mquant;
4090 s->ac_pred = get_bits1(gb);
4092 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4094 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4095 GET_MVDATA(dmv_x[0], dmv_y[0]);
4096 if (!mb_has_coeffs) {
4097 /* interpolated skipped block */
4098 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4099 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4103 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4105 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4108 s->ac_pred = get_bits1(gb);
4109 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4111 s->current_picture.f.qscale_table[mb_pos] = mquant;
4112 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4113 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4117 for (i = 0; i < 6; i++) {
4118 s->dc_val[0][s->block_index[i]] = 0;
4120 val = ((cbp >> (5 - i)) & 1);
4121 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4122 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4124 /* check if prediction blocks A and C are available */
4125 v->a_avail = v->c_avail = 0;
4126 if (i == 2 || i == 3 || !s->first_slice_line)
4127 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4128 if (i == 1 || i == 3 || s->mb_x)
4129 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4131 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4132 (i & 4) ? v->codingset2 : v->codingset);
4133 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4135 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4137 for (j = 0; j < 64; j++)
4138 s->block[i][j] <<= 1;
4139 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4141 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4142 first_block, s->dest[dst_idx] + off,
4143 (i & 4) ? s->uvlinesize : s->linesize,
4144 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4145 if (!v->ttmbf && ttmb < 8)
4152 /** Decode one B-frame MB (in interlaced field B picture)
4154 static void vc1_decode_b_mb_intfi(VC1Context *v)
4156 MpegEncContext *s = &v->s;
4157 GetBitContext *gb = &s->gb;
4159 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4160 int cbp = 0; /* cbp decoding stuff */
4161 int mqdiff, mquant; /* MB quantization */
4162 int ttmb = v->ttfrm; /* MB Transform type */
4163 int mb_has_coeffs = 0; /* last_flag */
4164 int val; /* temp value */
4165 int first_block = 1;
4168 int dmv_x[2], dmv_y[2], pred_flag[2];
4169 int bmvtype = BMV_TYPE_BACKWARD;
4170 int idx_mbmode, interpmvp;
4172 mquant = v->pq; /* Loosy initialization */
4175 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4176 if (idx_mbmode <= 1) { // intra MB
4177 s->mb_intra = v->is_intra[s->mb_x] = 1;
4178 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4179 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4180 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4182 s->current_picture.f.qscale_table[mb_pos] = mquant;
4183 /* Set DC scale - y and c use the same (not sure if necessary here) */
4184 s->y_dc_scale = s->y_dc_scale_table[mquant];
4185 s->c_dc_scale = s->c_dc_scale_table[mquant];
4186 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4187 mb_has_coeffs = idx_mbmode & 1;
4189 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4191 for (i = 0; i < 6; i++) {
4192 s->dc_val[0][s->block_index[i]] = 0;
4194 val = ((cbp >> (5 - i)) & 1);
4195 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4196 v->a_avail = v->c_avail = 0;
4197 if (i == 2 || i == 3 || !s->first_slice_line)
4198 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4199 if (i == 1 || i == 3 || s->mb_x)
4200 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4202 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4203 (i & 4) ? v->codingset2 : v->codingset);
4204 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4206 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4208 for (j = 0; j < 64; j++)
4209 s->block[i][j] <<= 1;
4210 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4211 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4212 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4213 // TODO: yet to perform loop filter
4216 s->mb_intra = v->is_intra[s->mb_x] = 0;
4217 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4218 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4220 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4222 fwd = v->forward_mb_plane[mb_pos];
4223 if (idx_mbmode <= 5) { // 1-MV
4224 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4225 pred_flag[0] = pred_flag[1] = 0;
4227 bmvtype = BMV_TYPE_FORWARD;
4229 bmvtype = decode012(gb);
4232 bmvtype = BMV_TYPE_BACKWARD;
4235 bmvtype = BMV_TYPE_DIRECT;
4238 bmvtype = BMV_TYPE_INTERPOLATED;
4239 interpmvp = get_bits1(gb);
4242 v->bmvtype = bmvtype;
4243 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4244 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4246 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4247 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4249 if (bmvtype == BMV_TYPE_DIRECT) {
4250 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4251 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4253 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4254 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4255 mb_has_coeffs = !(idx_mbmode & 2);
4258 bmvtype = BMV_TYPE_FORWARD;
4259 v->bmvtype = bmvtype;
4260 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4261 for (i = 0; i < 6; i++) {
4263 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4264 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4265 val = ((v->fourmvbp >> (3 - i)) & 1);
4267 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4268 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4269 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4271 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4272 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4274 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4276 mb_has_coeffs = idx_mbmode & 1;
4279 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4283 s->current_picture.f.qscale_table[mb_pos] = mquant;
4284 if (!v->ttmbf && cbp) {
4285 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4288 for (i = 0; i < 6; i++) {
4289 s->dc_val[0][s->block_index[i]] = 0;
4291 val = ((cbp >> (5 - i)) & 1);
4292 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4293 if (v->cur_field_type)
4294 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4296 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4297 first_block, s->dest[dst_idx] + off,
4298 (i & 4) ? s->uvlinesize : s->linesize,
4299 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4300 if (!v->ttmbf && ttmb < 8)
4308 /** Decode blocks of I-frame
4310 static void vc1_decode_i_blocks(VC1Context *v)
4313 MpegEncContext *s = &v->s;
4318 /* select codingmode used for VLC tables selection */
4319 switch (v->y_ac_table_index) {
4321 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4324 v->codingset = CS_HIGH_MOT_INTRA;
4327 v->codingset = CS_MID_RATE_INTRA;
4331 switch (v->c_ac_table_index) {
4333 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4336 v->codingset2 = CS_HIGH_MOT_INTER;
4339 v->codingset2 = CS_MID_RATE_INTER;
4343 /* Set DC scale - y and c use the same */
4344 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4345 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4348 s->mb_x = s->mb_y = 0;
4350 s->first_slice_line = 1;
4351 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4353 ff_init_block_index(s);
4354 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4356 ff_update_block_index(s);
4357 dst[0] = s->dest[0];
4358 dst[1] = dst[0] + 8;
4359 dst[2] = s->dest[0] + s->linesize * 8;
4360 dst[3] = dst[2] + 8;
4361 dst[4] = s->dest[1];
4362 dst[5] = s->dest[2];
4363 s->dsp.clear_blocks(s->block[0]);
4364 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4365 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
4366 s->current_picture.f.qscale_table[mb_pos] = v->pq;
4367 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4368 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4370 // do actual MB decoding and displaying
4371 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4372 v->s.ac_pred = get_bits1(&v->s.gb);
4374 for (k = 0; k < 6; k++) {
4375 val = ((cbp >> (5 - k)) & 1);
4378 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4382 cbp |= val << (5 - k);
4384 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4386 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4388 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4389 if (v->pq >= 9 && v->overlap) {
4391 for (j = 0; j < 64; j++)
4392 s->block[k][j] <<= 1;
4393 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4396 for (j = 0; j < 64; j++)
4397 s->block[k][j] = (s->block[k][j] - 64) << 1;
4398 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4402 if (v->pq >= 9 && v->overlap) {
4404 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4405 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4406 if (!(s->flags & CODEC_FLAG_GRAY)) {
4407 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4408 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4411 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4412 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4413 if (!s->first_slice_line) {
4414 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4415 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4416 if (!(s->flags & CODEC_FLAG_GRAY)) {
4417 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4418 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4421 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4422 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4424 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4426 if (get_bits_count(&s->gb) > v->bits) {
4427 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4428 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4429 get_bits_count(&s->gb), v->bits);
4433 if (!v->s.loop_filter)
4434 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4436 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4438 s->first_slice_line = 0;
4440 if (v->s.loop_filter)
4441 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4443 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4444 * profile, these only differ are when decoding MSS2 rectangles. */
4445 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4448 /** Decode blocks of I-frame for advanced profile
4450 static void vc1_decode_i_blocks_adv(VC1Context *v)
4453 MpegEncContext *s = &v->s;
4459 GetBitContext *gb = &s->gb;
4461 /* select codingmode used for VLC tables selection */
4462 switch (v->y_ac_table_index) {
4464 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4467 v->codingset = CS_HIGH_MOT_INTRA;
4470 v->codingset = CS_MID_RATE_INTRA;
4474 switch (v->c_ac_table_index) {
4476 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4479 v->codingset2 = CS_HIGH_MOT_INTER;
4482 v->codingset2 = CS_MID_RATE_INTER;
4487 s->mb_x = s->mb_y = 0;
4489 s->first_slice_line = 1;
4490 s->mb_y = s->start_mb_y;
4491 if (s->start_mb_y) {
4493 ff_init_block_index(s);
4494 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4495 (1 + s->b8_stride) * sizeof(*s->coded_block));
4497 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4499 ff_init_block_index(s);
4500 for (;s->mb_x < s->mb_width; s->mb_x++) {
4501 DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
4502 ff_update_block_index(s);
4503 s->dsp.clear_blocks(block[0]);
4504 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4505 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4506 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4507 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4509 // do actual MB decoding and displaying
4510 if (v->fieldtx_is_raw)
4511 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4512 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4513 if ( v->acpred_is_raw)
4514 v->s.ac_pred = get_bits1(&v->s.gb);
4516 v->s.ac_pred = v->acpred_plane[mb_pos];
4518 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4519 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4523 s->current_picture.f.qscale_table[mb_pos] = mquant;
4524 /* Set DC scale - y and c use the same */
4525 s->y_dc_scale = s->y_dc_scale_table[mquant];
4526 s->c_dc_scale = s->c_dc_scale_table[mquant];
4528 for (k = 0; k < 6; k++) {
4529 val = ((cbp >> (5 - k)) & 1);
4532 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4536 cbp |= val << (5 - k);
4538 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4539 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4541 vc1_decode_i_block_adv(v, block[k], k, val,
4542 (k < 4) ? v->codingset : v->codingset2, mquant);
4544 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4546 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4549 vc1_smooth_overlap_filter_iblk(v);
4550 vc1_put_signed_blocks_clamped(v);
4551 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4553 if (get_bits_count(&s->gb) > v->bits) {
4554 // TODO: may need modification to handle slice coding
4555 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4556 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4557 get_bits_count(&s->gb), v->bits);
4561 if (!v->s.loop_filter)
4562 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4564 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4565 s->first_slice_line = 0;
4568 /* raw bottom MB row */
4570 ff_init_block_index(s);
4571 for (;s->mb_x < s->mb_width; s->mb_x++) {
4572 ff_update_block_index(s);
4573 vc1_put_signed_blocks_clamped(v);
4574 if (v->s.loop_filter)
4575 vc1_loop_filter_iblk_delayed(v, v->pq);
4577 if (v->s.loop_filter)
4578 ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4579 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4580 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4583 static void vc1_decode_p_blocks(VC1Context *v)
4585 MpegEncContext *s = &v->s;
4586 int apply_loop_filter;
4588 /* select codingmode used for VLC tables selection */
4589 switch (v->c_ac_table_index) {
4591 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4594 v->codingset = CS_HIGH_MOT_INTRA;
4597 v->codingset = CS_MID_RATE_INTRA;
4601 switch (v->c_ac_table_index) {
4603 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4606 v->codingset2 = CS_HIGH_MOT_INTER;
4609 v->codingset2 = CS_MID_RATE_INTER;
4613 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
4614 s->first_slice_line = 1;
4615 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
4616 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4618 ff_init_block_index(s);
4619 for (; s->mb_x < s->mb_width; s->mb_x++) {
4620 ff_update_block_index(s);
4622 if (v->fcm == ILACE_FIELD)
4623 vc1_decode_p_mb_intfi(v);
4624 else if (v->fcm == ILACE_FRAME)
4625 vc1_decode_p_mb_intfr(v);
4626 else vc1_decode_p_mb(v);
4627 if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == PROGRESSIVE)
4628 vc1_apply_p_loop_filter(v);
4629 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4630 // TODO: may need modification to handle slice coding
4631 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4632 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4633 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4637 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
4638 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
4639 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4640 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
4641 if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4642 s->first_slice_line = 0;
4644 if (apply_loop_filter) {
4646 ff_init_block_index(s);
4647 for (; s->mb_x < s->mb_width; s->mb_x++) {
4648 ff_update_block_index(s);
4649 vc1_apply_p_loop_filter(v);
4652 if (s->end_mb_y >= s->start_mb_y)
4653 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4654 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4655 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4658 static void vc1_decode_b_blocks(VC1Context *v)
4660 MpegEncContext *s = &v->s;
4662 /* select codingmode used for VLC tables selection */
4663 switch (v->c_ac_table_index) {
4665 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4668 v->codingset = CS_HIGH_MOT_INTRA;
4671 v->codingset = CS_MID_RATE_INTRA;
4675 switch (v->c_ac_table_index) {
4677 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4680 v->codingset2 = CS_HIGH_MOT_INTER;
4683 v->codingset2 = CS_MID_RATE_INTER;
4687 s->first_slice_line = 1;
4688 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4690 ff_init_block_index(s);
4691 for (; s->mb_x < s->mb_width; s->mb_x++) {
4692 ff_update_block_index(s);
4694 if (v->fcm == ILACE_FIELD)
4695 vc1_decode_b_mb_intfi(v);
4698 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4699 // TODO: may need modification to handle slice coding
4700 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4701 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4702 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4705 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4707 if (!v->s.loop_filter)
4708 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4710 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4711 s->first_slice_line = 0;
4713 if (v->s.loop_filter)
4714 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4715 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4716 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4719 static void vc1_decode_skip_blocks(VC1Context *v)
4721 MpegEncContext *s = &v->s;
4723 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
4724 s->first_slice_line = 1;
4725 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4727 ff_init_block_index(s);
4728 ff_update_block_index(s);
4729 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4730 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4731 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4732 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4733 s->first_slice_line = 0;
4735 s->pict_type = AV_PICTURE_TYPE_P;
4738 void ff_vc1_decode_blocks(VC1Context *v)
4741 v->s.esc3_level_length = 0;
4743 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
4746 v->left_blk_idx = -1;
4747 v->topleft_blk_idx = 1;
4749 switch (v->s.pict_type) {
4750 case AV_PICTURE_TYPE_I:
4751 if (v->profile == PROFILE_ADVANCED)
4752 vc1_decode_i_blocks_adv(v);
4754 vc1_decode_i_blocks(v);
4756 case AV_PICTURE_TYPE_P:
4757 if (v->p_frame_skipped)
4758 vc1_decode_skip_blocks(v);
4760 vc1_decode_p_blocks(v);
4762 case AV_PICTURE_TYPE_B:
4764 if (v->profile == PROFILE_ADVANCED)
4765 vc1_decode_i_blocks_adv(v);
4767 vc1_decode_i_blocks(v);
4769 vc1_decode_b_blocks(v);
4775 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
4779 * Transform coefficients for both sprites in 16.16 fixed point format,
4780 * in the order they appear in the bitstream:
4782 * rotation 1 (unused)
4784 * rotation 2 (unused)
4791 int effect_type, effect_flag;
4792 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
4793 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
4796 static inline int get_fp_val(GetBitContext* gb)
4798 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
4801 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
4805 switch (get_bits(gb, 2)) {
4808 c[2] = get_fp_val(gb);
4812 c[0] = c[4] = get_fp_val(gb);
4813 c[2] = get_fp_val(gb);
4816 c[0] = get_fp_val(gb);
4817 c[2] = get_fp_val(gb);
4818 c[4] = get_fp_val(gb);
4821 c[0] = get_fp_val(gb);
4822 c[1] = get_fp_val(gb);
4823 c[2] = get_fp_val(gb);
4824 c[3] = get_fp_val(gb);
4825 c[4] = get_fp_val(gb);
4828 c[5] = get_fp_val(gb);
4830 c[6] = get_fp_val(gb);
4835 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
4837 AVCodecContext *avctx = v->s.avctx;
4840 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4841 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
4842 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
4843 av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
4844 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
4845 for (i = 0; i < 7; i++)
4846 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
4847 sd->coefs[sprite][i] / (1<<16),
4848 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
4849 av_log(avctx, AV_LOG_DEBUG, "\n");
4853 if (sd->effect_type = get_bits_long(gb, 30)) {
4854 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
4856 vc1_sprite_parse_transform(gb, sd->effect_params1);
4859 vc1_sprite_parse_transform(gb, sd->effect_params1);
4860 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
4863 for (i = 0; i < sd->effect_pcount1; i++)
4864 sd->effect_params1[i] = get_fp_val(gb);
4866 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
4867 // effect 13 is simple alpha blending and matches the opacity above
4868 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
4869 for (i = 0; i < sd->effect_pcount1; i++)
4870 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4871 sd->effect_params1[i] / (1 << 16),
4872 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
4873 av_log(avctx, AV_LOG_DEBUG, "\n");
4876 sd->effect_pcount2 = get_bits(gb, 16);
4877 if (sd->effect_pcount2 > 10) {
4878 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
4880 } else if (sd->effect_pcount2) {
4882 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
4883 while (++i < sd->effect_pcount2) {
4884 sd->effect_params2[i] = get_fp_val(gb);
4885 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4886 sd->effect_params2[i] / (1 << 16),
4887 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
4889 av_log(avctx, AV_LOG_DEBUG, "\n");
4892 if (sd->effect_flag = get_bits1(gb))
4893 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4895 if (get_bits_count(gb) >= gb->size_in_bits +
4896 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
4897 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4898 if (get_bits_count(gb) < gb->size_in_bits - 8)
4899 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4902 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
4904 int i, plane, row, sprite;
4905 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
4906 uint8_t* src_h[2][2];
4907 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
4909 MpegEncContext *s = &v->s;
4911 for (i = 0; i < 2; i++) {
4912 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
4913 xadv[i] = sd->coefs[i][0];
4914 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
4915 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
4917 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
4918 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
4920 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
4922 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
4923 int width = v->output_width>>!!plane;
4925 for (row = 0; row < v->output_height>>!!plane; row++) {
4926 uint8_t *dst = v->sprite_output_frame.data[plane] +
4927 v->sprite_output_frame.linesize[plane] * row;
4929 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4930 uint8_t *iplane = s->current_picture.f.data[plane];
4931 int iline = s->current_picture.f.linesize[plane];
4932 int ycoord = yoff[sprite] + yadv[sprite] * row;
4933 int yline = ycoord >> 16;
4935 ysub[sprite] = ycoord & 0xFFFF;
4937 iplane = s->last_picture.f.data[plane];
4938 iline = s->last_picture.f.linesize[plane];
4940 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
4941 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4942 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
4944 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
4946 if (sr_cache[sprite][0] != yline) {
4947 if (sr_cache[sprite][1] == yline) {
4948 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
4949 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
4951 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
4952 sr_cache[sprite][0] = yline;
4955 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4956 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
4957 iplane + next_line, xoff[sprite],
4958 xadv[sprite], width);
4959 sr_cache[sprite][1] = yline + 1;
4961 src_h[sprite][0] = v->sr_rows[sprite][0];
4962 src_h[sprite][1] = v->sr_rows[sprite][1];
4966 if (!v->two_sprites) {
4968 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
4970 memcpy(dst, src_h[0][0], width);
4973 if (ysub[0] && ysub[1]) {
4974 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
4975 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
4976 } else if (ysub[0]) {
4977 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
4978 src_h[1][0], alpha, width);
4979 } else if (ysub[1]) {
4980 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
4981 src_h[0][0], (1<<16)-1-alpha, width);
4983 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
4989 for (i = 0; i < 2; i++) {
4999 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5001 MpegEncContext *s = &v->s;
5002 AVCodecContext *avctx = s->avctx;
5005 vc1_parse_sprites(v, gb, &sd);
5007 if (!s->current_picture.f.data[0]) {
5008 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5012 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5013 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5017 if (v->sprite_output_frame.data[0])
5018 avctx->release_buffer(avctx, &v->sprite_output_frame);
5020 v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5021 v->sprite_output_frame.reference = 0;
5022 if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
5023 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5027 vc1_draw_sprites(v, &sd);
5032 static void vc1_sprite_flush(AVCodecContext *avctx)
5034 VC1Context *v = avctx->priv_data;
5035 MpegEncContext *s = &v->s;
5036 AVFrame *f = &s->current_picture.f;
5039 /* Windows Media Image codecs have a convergence interval of two keyframes.
5040 Since we can't enforce it, clear to black the missing sprite. This is
5041 wrong but it looks better than doing nothing. */
5044 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5045 for (i = 0; i < v->sprite_height>>!!plane; i++)
5046 memset(f->data[plane] + i * f->linesize[plane],
5047 plane ? 128 : 0, f->linesize[plane]);
5052 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5054 MpegEncContext *s = &v->s;
5057 /* Allocate mb bitplanes */
5058 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5059 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5060 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5061 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5062 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5063 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5065 v->n_allocated_blks = s->mb_width + 2;
5066 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5067 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5068 v->cbp = v->cbp_base + s->mb_stride;
5069 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5070 v->ttblk = v->ttblk_base + s->mb_stride;
5071 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5072 v->is_intra = v->is_intra_base + s->mb_stride;
5073 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5074 v->luma_mv = v->luma_mv_base + s->mb_stride;
5076 /* allocate block type info in that way so it could be used with s->block_index[] */
5077 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5078 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5079 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5080 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5082 /* allocate memory to store block level MV info */
5083 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5084 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5085 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5086 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5087 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5088 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5089 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
5090 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);
5091 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5092 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5093 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);
5095 /* Init coded blocks info */
5096 if (v->profile == PROFILE_ADVANCED) {
5097 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5099 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5103 ff_intrax8_common_init(&v->x8,s);
5105 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5106 for (i = 0; i < 4; i++)
5107 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5110 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5111 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5118 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5121 for (i = 0; i < 64; i++) {
5122 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5123 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5124 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5125 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5126 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5127 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5133 /** Initialize a VC1/WMV3 decoder
5134 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5135 * @todo TODO: Decypher remaining bits in extra_data
5137 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5139 VC1Context *v = avctx->priv_data;
5140 MpegEncContext *s = &v->s;
5143 /* save the container output size for WMImage */
5144 v->output_width = avctx->width;
5145 v->output_height = avctx->height;
5147 if (!avctx->extradata_size || !avctx->extradata)
5149 if (!(avctx->flags & CODEC_FLAG_GRAY))
5150 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5152 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5153 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5155 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5156 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5158 if (avctx->idct_algo == FF_IDCT_AUTO) {
5159 avctx->idct_algo = FF_IDCT_WMV2;
5162 if (ff_vc1_init_common(v) < 0)
5164 ff_vc1dsp_init(&v->vc1dsp);
5166 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5169 // looks like WMV3 has a sequence header stored in the extradata
5170 // advanced sequence header may be before the first frame
5171 // the last byte of the extradata is a version number, 1 for the
5172 // samples we can decode
5174 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5176 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5179 count = avctx->extradata_size*8 - get_bits_count(&gb);
5181 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5182 count, get_bits(&gb, count));
5183 } else if (count < 0) {
5184 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5186 } else { // VC1/WVC1/WVP2
5187 const uint8_t *start = avctx->extradata;
5188 uint8_t *end = avctx->extradata + avctx->extradata_size;
5189 const uint8_t *next;
5190 int size, buf2_size;
5191 uint8_t *buf2 = NULL;
5192 int seq_initialized = 0, ep_initialized = 0;
5194 if (avctx->extradata_size < 16) {
5195 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5199 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5200 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5202 for (; next < end; start = next) {
5203 next = find_next_marker(start + 4, end);
5204 size = next - start - 4;
5207 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5208 init_get_bits(&gb, buf2, buf2_size * 8);
5209 switch (AV_RB32(start)) {
5210 case VC1_CODE_SEQHDR:
5211 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5215 seq_initialized = 1;
5217 case VC1_CODE_ENTRYPOINT:
5218 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5227 if (!seq_initialized || !ep_initialized) {
5228 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5231 v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
5234 avctx->profile = v->profile;
5235 if (v->profile == PROFILE_ADVANCED)
5236 avctx->level = v->level;
5238 avctx->has_b_frames = !!avctx->max_b_frames;
5240 s->mb_width = (avctx->coded_width + 15) >> 4;
5241 s->mb_height = (avctx->coded_height + 15) >> 4;
5243 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5244 ff_vc1_init_transposed_scantables(v);
5246 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5251 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5252 v->sprite_width = avctx->coded_width;
5253 v->sprite_height = avctx->coded_height;
5255 avctx->coded_width = avctx->width = v->output_width;
5256 avctx->coded_height = avctx->height = v->output_height;
5258 // prevent 16.16 overflows
5259 if (v->sprite_width > 1 << 14 ||
5260 v->sprite_height > 1 << 14 ||
5261 v->output_width > 1 << 14 ||
5262 v->output_height > 1 << 14) return -1;
5267 /** Close a VC1/WMV3 decoder
5268 * @warning Initial try at using MpegEncContext stuff
5270 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5272 VC1Context *v = avctx->priv_data;
5275 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5276 && v->sprite_output_frame.data[0])
5277 avctx->release_buffer(avctx, &v->sprite_output_frame);
5278 for (i = 0; i < 4; i++)
5279 av_freep(&v->sr_rows[i >> 1][i & 1]);
5280 av_freep(&v->hrd_rate);
5281 av_freep(&v->hrd_buffer);
5282 ff_MPV_common_end(&v->s);
5283 av_freep(&v->mv_type_mb_plane);
5284 av_freep(&v->direct_mb_plane);
5285 av_freep(&v->forward_mb_plane);
5286 av_freep(&v->fieldtx_plane);
5287 av_freep(&v->acpred_plane);
5288 av_freep(&v->over_flags_plane);
5289 av_freep(&v->mb_type_base);
5290 av_freep(&v->blk_mv_type_base);
5291 av_freep(&v->mv_f_base);
5292 av_freep(&v->mv_f_last_base);
5293 av_freep(&v->mv_f_next_base);
5294 av_freep(&v->block);
5295 av_freep(&v->cbp_base);
5296 av_freep(&v->ttblk_base);
5297 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5298 av_freep(&v->luma_mv_base);
5299 ff_intrax8_common_end(&v->x8);
5304 /** Decode a VC1/WMV3 frame
5305 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5307 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5308 int *data_size, AVPacket *avpkt)
5310 const uint8_t *buf = avpkt->data;
5311 int buf_size = avpkt->size, n_slices = 0, i;
5312 VC1Context *v = avctx->priv_data;
5313 MpegEncContext *s = &v->s;
5314 AVFrame *pict = data;
5315 uint8_t *buf2 = NULL;
5316 const uint8_t *buf_start = buf;
5317 int mb_height, n_slices1;
5322 } *slices = NULL, *tmp;
5324 /* no supplementary picture */
5325 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5326 /* special case for last picture */
5327 if (s->low_delay == 0 && s->next_picture_ptr) {
5328 *pict = s->next_picture_ptr->f;
5329 s->next_picture_ptr = NULL;
5331 *data_size = sizeof(AVFrame);
5337 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5338 if (v->profile < PROFILE_ADVANCED)
5339 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5341 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5344 //for advanced profile we may need to parse and unescape data
5345 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5347 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5349 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5350 const uint8_t *start, *end, *next;
5354 for (start = buf, end = buf + buf_size; next < end; start = next) {
5355 next = find_next_marker(start + 4, end);
5356 size = next - start - 4;
5357 if (size <= 0) continue;
5358 switch (AV_RB32(start)) {
5359 case VC1_CODE_FRAME:
5360 if (avctx->hwaccel ||
5361 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5363 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5365 case VC1_CODE_FIELD: {
5367 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5371 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5372 if (!slices[n_slices].buf)
5374 buf_size3 = vc1_unescape_buffer(start + 4, size,
5375 slices[n_slices].buf);
5376 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5378 /* assuming that the field marker is at the exact middle,
5379 hope it's correct */
5380 slices[n_slices].mby_start = s->mb_height >> 1;
5381 n_slices1 = n_slices - 1; // index of the last slice of the first field
5385 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5386 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5387 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5388 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5390 case VC1_CODE_SLICE: {
5392 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5396 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5397 if (!slices[n_slices].buf)
5399 buf_size3 = vc1_unescape_buffer(start + 4, size,
5400 slices[n_slices].buf);
5401 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5403 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5409 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5410 const uint8_t *divider;
5413 divider = find_next_marker(buf, buf + buf_size);
5414 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5415 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5417 } else { // found field marker, unescape second field
5418 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5422 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5423 if (!slices[n_slices].buf)
5425 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5426 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5428 slices[n_slices].mby_start = s->mb_height >> 1;
5429 n_slices1 = n_slices - 1;
5432 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5434 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5436 init_get_bits(&s->gb, buf2, buf_size2*8);
5438 init_get_bits(&s->gb, buf, buf_size*8);
5440 if (v->res_sprite) {
5441 v->new_sprite = !get_bits1(&s->gb);
5442 v->two_sprites = get_bits1(&s->gb);
5443 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5444 we're using the sprite compositor. These are intentionally kept separate
5445 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5446 the vc1 one for WVP2 */
5447 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5448 if (v->new_sprite) {
5449 // switch AVCodecContext parameters to those of the sprites
5450 avctx->width = avctx->coded_width = v->sprite_width;
5451 avctx->height = avctx->coded_height = v->sprite_height;
5458 if (s->context_initialized &&
5459 (s->width != avctx->coded_width ||
5460 s->height != avctx->coded_height)) {
5461 ff_vc1_decode_end(avctx);
5464 if (!s->context_initialized) {
5465 if (ff_msmpeg4_decode_init(avctx) < 0 || ff_vc1_decode_init_alloc_tables(v) < 0)
5468 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5470 if (v->profile == PROFILE_ADVANCED) {
5471 s->h_edge_pos = avctx->coded_width;
5472 s->v_edge_pos = avctx->coded_height;
5476 /* We need to set current_picture_ptr before reading the header,
5477 * otherwise we cannot store anything in there. */
5478 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5479 int i = ff_find_unused_picture(s, 0);
5482 s->current_picture_ptr = &s->picture[i];
5485 // do parse frame header
5486 v->pic_header_flag = 0;
5487 if (v->profile < PROFILE_ADVANCED) {
5488 if (ff_vc1_parse_frame_header(v, &s->gb) == -1) {
5492 if (ff_vc1_parse_frame_header_adv(v, &s->gb) == -1) {
5497 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5498 && s->pict_type != AV_PICTURE_TYPE_I) {
5499 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5503 // process pulldown flags
5504 s->current_picture_ptr->f.repeat_pict = 0;
5505 // Pulldown flags are only valid when 'broadcast' has been set.
5506 // So ticks_per_frame will be 2
5509 s->current_picture_ptr->f.repeat_pict = 1;
5510 } else if (v->rptfrm) {
5512 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5515 // for skipping the frame
5516 s->current_picture.f.pict_type = s->pict_type;
5517 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5519 /* skip B-frames if we don't have reference frames */
5520 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
5523 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5524 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5525 avctx->skip_frame >= AVDISCARD_ALL) {
5529 if (s->next_p_frame_damaged) {
5530 if (s->pict_type == AV_PICTURE_TYPE_B)
5533 s->next_p_frame_damaged = 0;
5536 if (ff_MPV_frame_start(s, avctx) < 0) {
5540 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5541 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5543 if ((CONFIG_VC1_VDPAU_DECODER)
5544 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5545 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5546 else if (avctx->hwaccel) {
5547 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
5549 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5551 if (avctx->hwaccel->end_frame(avctx) < 0)
5554 ff_er_frame_start(s);
5556 v->bits = buf_size * 8;
5557 v->end_mb_x = s->mb_width;
5558 if (v->field_mode) {
5560 s->current_picture.f.linesize[0] <<= 1;
5561 s->current_picture.f.linesize[1] <<= 1;
5562 s->current_picture.f.linesize[2] <<= 1;
5564 s->uvlinesize <<= 1;
5565 tmp[0] = v->mv_f_last[0];
5566 tmp[1] = v->mv_f_last[1];
5567 v->mv_f_last[0] = v->mv_f_next[0];
5568 v->mv_f_last[1] = v->mv_f_next[1];
5569 v->mv_f_next[0] = v->mv_f[0];
5570 v->mv_f_next[1] = v->mv_f[1];
5571 v->mv_f[0] = tmp[0];
5572 v->mv_f[1] = tmp[1];
5574 mb_height = s->mb_height >> v->field_mode;
5575 for (i = 0; i <= n_slices; i++) {
5576 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5577 if (v->field_mode <= 0) {
5578 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
5579 "picture boundary (%d >= %d)\n", i,
5580 slices[i - 1].mby_start, mb_height);
5583 v->second_field = 1;
5584 v->blocks_off = s->mb_width * s->mb_height << 1;
5585 v->mb_off = s->mb_stride * s->mb_height >> 1;
5587 v->second_field = 0;
5592 v->pic_header_flag = 0;
5593 if (v->field_mode && i == n_slices1 + 2) {
5594 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5595 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
5598 } else if (get_bits1(&s->gb)) {
5599 v->pic_header_flag = 1;
5600 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5601 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
5606 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5607 if (!v->field_mode || v->second_field)
5608 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5610 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5611 ff_vc1_decode_blocks(v);
5613 s->gb = slices[i].gb;
5615 if (v->field_mode) {
5616 v->second_field = 0;
5617 if (s->pict_type == AV_PICTURE_TYPE_B) {
5618 memcpy(v->mv_f_base, v->mv_f_next_base,
5619 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5621 s->current_picture.f.linesize[0] >>= 1;
5622 s->current_picture.f.linesize[1] >>= 1;
5623 s->current_picture.f.linesize[2] >>= 1;
5625 s->uvlinesize >>= 1;
5627 av_dlog(s->avctx, "Consumed %i/%i bits\n",
5628 get_bits_count(&s->gb), s->gb.size_in_bits);
5629 // if (get_bits_count(&s->gb) > buf_size * 8)
5634 ff_MPV_frame_end(s);
5636 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5638 avctx->width = avctx->coded_width = v->output_width;
5639 avctx->height = avctx->coded_height = v->output_height;
5640 if (avctx->skip_frame >= AVDISCARD_NONREF)
5642 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5643 if (vc1_decode_sprites(v, &s->gb))
5646 *pict = v->sprite_output_frame;
5647 *data_size = sizeof(AVFrame);
5649 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5650 *pict = s->current_picture_ptr->f;
5651 } else if (s->last_picture_ptr != NULL) {
5652 *pict = s->last_picture_ptr->f;
5654 if (s->last_picture_ptr || s->low_delay) {
5655 *data_size = sizeof(AVFrame);
5656 ff_print_debug_info(s, pict);
5662 for (i = 0; i < n_slices; i++)
5663 av_free(slices[i].buf);
5669 for (i = 0; i < n_slices; i++)
5670 av_free(slices[i].buf);
5676 static const AVProfile profiles[] = {
5677 { FF_PROFILE_VC1_SIMPLE, "Simple" },
5678 { FF_PROFILE_VC1_MAIN, "Main" },
5679 { FF_PROFILE_VC1_COMPLEX, "Complex" },
5680 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5681 { FF_PROFILE_UNKNOWN },
5684 AVCodec ff_vc1_decoder = {
5686 .type = AVMEDIA_TYPE_VIDEO,
5687 .id = AV_CODEC_ID_VC1,
5688 .priv_data_size = sizeof(VC1Context),
5689 .init = vc1_decode_init,
5690 .close = ff_vc1_decode_end,
5691 .decode = vc1_decode_frame,
5692 .flush = ff_mpeg_flush,
5693 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5694 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5695 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5696 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5699 #if CONFIG_WMV3_DECODER
5700 AVCodec ff_wmv3_decoder = {
5702 .type = AVMEDIA_TYPE_VIDEO,
5703 .id = AV_CODEC_ID_WMV3,
5704 .priv_data_size = sizeof(VC1Context),
5705 .init = vc1_decode_init,
5706 .close = ff_vc1_decode_end,
5707 .decode = vc1_decode_frame,
5708 .flush = ff_mpeg_flush,
5709 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5710 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5711 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5712 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5716 #if CONFIG_WMV3_VDPAU_DECODER
5717 AVCodec ff_wmv3_vdpau_decoder = {
5718 .name = "wmv3_vdpau",
5719 .type = AVMEDIA_TYPE_VIDEO,
5720 .id = AV_CODEC_ID_WMV3,
5721 .priv_data_size = sizeof(VC1Context),
5722 .init = vc1_decode_init,
5723 .close = ff_vc1_decode_end,
5724 .decode = vc1_decode_frame,
5725 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5726 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5727 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
5728 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5732 #if CONFIG_VC1_VDPAU_DECODER
5733 AVCodec ff_vc1_vdpau_decoder = {
5734 .name = "vc1_vdpau",
5735 .type = AVMEDIA_TYPE_VIDEO,
5736 .id = AV_CODEC_ID_VC1,
5737 .priv_data_size = sizeof(VC1Context),
5738 .init = vc1_decode_init,
5739 .close = ff_vc1_decode_end,
5740 .decode = vc1_decode_frame,
5741 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5742 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5743 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
5744 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5748 #if CONFIG_WMV3IMAGE_DECODER
5749 AVCodec ff_wmv3image_decoder = {
5750 .name = "wmv3image",
5751 .type = AVMEDIA_TYPE_VIDEO,
5752 .id = AV_CODEC_ID_WMV3IMAGE,
5753 .priv_data_size = sizeof(VC1Context),
5754 .init = vc1_decode_init,
5755 .close = ff_vc1_decode_end,
5756 .decode = vc1_decode_frame,
5757 .capabilities = CODEC_CAP_DR1,
5758 .flush = vc1_sprite_flush,
5759 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5760 .pix_fmts = ff_pixfmt_list_420
5764 #if CONFIG_VC1IMAGE_DECODER
5765 AVCodec ff_vc1image_decoder = {
5767 .type = AVMEDIA_TYPE_VIDEO,
5768 .id = AV_CODEC_ID_VC1IMAGE,
5769 .priv_data_size = sizeof(VC1Context),
5770 .init = vc1_decode_init,
5771 .close = ff_vc1_decode_end,
5772 .decode = vc1_decode_frame,
5773 .capabilities = CODEC_CAP_DR1,
5774 .flush = vc1_sprite_flush,
5775 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5776 .pix_fmts = ff_pixfmt_list_420