2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
32 #include "mpegvideo.h"
36 #include "vc1acdata.h"
37 #include "msmpeg4data.h"
40 #include "vdpau_internal.h"
41 #include "libavutil/avassert.h"
46 #define MB_INTRA_VLC_BITS 9
50 // offset tables for interlaced picture MVDATA decoding
51 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
52 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
54 /***********************************************************************/
56 * @name VC-1 Bitplane decoding
74 /** @} */ //imode defines
77 /** @} */ //Bitplane group
79 static void vc1_put_signed_blocks_clamped(VC1Context *v)
81 MpegEncContext *s = &v->s;
82 int topleft_mb_pos, top_mb_pos;
83 int stride_y, fieldtx;
86 /* The put pixels loop is always one MB row behind the decoding loop,
87 * because we can only put pixels when overlap filtering is done, and
88 * for filtering of the bottom edge of a MB, we need the next MB row
90 * Within the row, the put pixels loop is also one MB col behind the
91 * decoding loop. The reason for this is again, because for filtering
92 * of the right MB edge, we need the next MB present. */
93 if (!s->first_slice_line) {
95 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
96 fieldtx = v->fieldtx_plane[topleft_mb_pos];
97 stride_y = s->linesize << fieldtx;
98 v_dist = (16 - fieldtx) >> (fieldtx == 0);
99 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
100 s->dest[0] - 16 * s->linesize - 16,
102 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
103 s->dest[0] - 16 * s->linesize - 8,
105 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
106 s->dest[0] - v_dist * s->linesize - 16,
108 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
109 s->dest[0] - v_dist * s->linesize - 8,
111 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
112 s->dest[1] - 8 * s->uvlinesize - 8,
114 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
115 s->dest[2] - 8 * s->uvlinesize - 8,
118 if (s->mb_x == s->mb_width - 1) {
119 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
120 fieldtx = v->fieldtx_plane[top_mb_pos];
121 stride_y = s->linesize << fieldtx;
122 v_dist = fieldtx ? 15 : 8;
123 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
124 s->dest[0] - 16 * s->linesize,
126 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
127 s->dest[0] - 16 * s->linesize + 8,
129 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
130 s->dest[0] - v_dist * s->linesize,
132 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
133 s->dest[0] - v_dist * s->linesize + 8,
135 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
136 s->dest[1] - 8 * s->uvlinesize,
138 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
139 s->dest[2] - 8 * s->uvlinesize,
144 #define inc_blk_idx(idx) do { \
146 if (idx >= v->n_allocated_blks) \
150 inc_blk_idx(v->topleft_blk_idx);
151 inc_blk_idx(v->top_blk_idx);
152 inc_blk_idx(v->left_blk_idx);
153 inc_blk_idx(v->cur_blk_idx);
156 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
158 MpegEncContext *s = &v->s;
160 if (!s->first_slice_line) {
161 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
163 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
164 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
165 for (j = 0; j < 2; j++) {
166 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
168 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
171 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
173 if (s->mb_y == s->end_mb_y - 1) {
175 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
176 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
177 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
179 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
183 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
185 MpegEncContext *s = &v->s;
188 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
189 * means it runs two rows/cols behind the decoding loop. */
190 if (!s->first_slice_line) {
192 if (s->mb_y >= s->start_mb_y + 2) {
193 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
196 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
197 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
198 for (j = 0; j < 2; j++) {
199 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
201 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
205 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
208 if (s->mb_x == s->mb_width - 1) {
209 if (s->mb_y >= s->start_mb_y + 2) {
210 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
213 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
214 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
215 for (j = 0; j < 2; j++) {
216 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
218 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
222 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
225 if (s->mb_y == s->end_mb_y) {
228 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
229 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
231 for (j = 0; j < 2; j++) {
232 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
237 if (s->mb_x == s->mb_width - 1) {
239 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
240 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
242 for (j = 0; j < 2; j++) {
243 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
251 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
253 MpegEncContext *s = &v->s;
256 if (v->condover == CONDOVER_NONE)
259 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
261 /* Within a MB, the horizontal overlap always runs before the vertical.
262 * To accomplish that, we run the H on left and internal borders of the
263 * currently decoded MB. Then, we wait for the next overlap iteration
264 * to do H overlap on the right edge of this MB, before moving over and
265 * running the V overlap. Therefore, the V overlap makes us trail by one
266 * MB col and the H overlap filter makes us trail by one MB row. This
267 * is reflected in the time at which we run the put_pixels loop. */
268 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
269 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
270 v->over_flags_plane[mb_pos - 1])) {
271 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
272 v->block[v->cur_blk_idx][0]);
273 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
274 v->block[v->cur_blk_idx][2]);
275 if (!(s->flags & CODEC_FLAG_GRAY)) {
276 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
277 v->block[v->cur_blk_idx][4]);
278 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
279 v->block[v->cur_blk_idx][5]);
282 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
283 v->block[v->cur_blk_idx][1]);
284 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
285 v->block[v->cur_blk_idx][3]);
287 if (s->mb_x == s->mb_width - 1) {
288 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
289 v->over_flags_plane[mb_pos - s->mb_stride])) {
290 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
291 v->block[v->cur_blk_idx][0]);
292 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
293 v->block[v->cur_blk_idx][1]);
294 if (!(s->flags & CODEC_FLAG_GRAY)) {
295 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
296 v->block[v->cur_blk_idx][4]);
297 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
298 v->block[v->cur_blk_idx][5]);
301 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
302 v->block[v->cur_blk_idx][2]);
303 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
304 v->block[v->cur_blk_idx][3]);
307 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
308 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
309 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
310 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
311 v->block[v->left_blk_idx][0]);
312 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
313 v->block[v->left_blk_idx][1]);
314 if (!(s->flags & CODEC_FLAG_GRAY)) {
315 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
316 v->block[v->left_blk_idx][4]);
317 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
318 v->block[v->left_blk_idx][5]);
321 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
322 v->block[v->left_blk_idx][2]);
323 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
324 v->block[v->left_blk_idx][3]);
328 /** Do motion compensation over 1 macroblock
329 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
331 static void vc1_mc_1mv(VC1Context *v, int dir)
333 MpegEncContext *s = &v->s;
334 DSPContext *dsp = &v->s.dsp;
335 uint8_t *srcY, *srcU, *srcV;
336 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
338 int v_edge_pos = s->v_edge_pos >> v->field_mode;
340 if ((!v->field_mode ||
341 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
342 !v->s.last_picture.f.data[0])
345 mx = s->mv[dir][0][0];
346 my = s->mv[dir][0][1];
348 // store motion vectors for further use in B frames
349 if (s->pict_type == AV_PICTURE_TYPE_P) {
350 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
351 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
354 uvmx = (mx + ((mx & 3) == 3)) >> 1;
355 uvmy = (my + ((my & 3) == 3)) >> 1;
356 v->luma_mv[s->mb_x][0] = uvmx;
357 v->luma_mv[s->mb_x][1] = uvmy;
360 v->cur_field_type != v->ref_field_type[dir]) {
361 my = my - 2 + 4 * v->cur_field_type;
362 uvmy = uvmy - 2 + 4 * v->cur_field_type;
365 // fastuvmc shall be ignored for interlaced frame picture
366 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
367 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
368 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
370 if (v->field_mode) { // interlaced field picture
372 if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
373 srcY = s->current_picture.f.data[0];
374 srcU = s->current_picture.f.data[1];
375 srcV = s->current_picture.f.data[2];
377 srcY = s->last_picture.f.data[0];
378 srcU = s->last_picture.f.data[1];
379 srcV = s->last_picture.f.data[2];
382 srcY = s->next_picture.f.data[0];
383 srcU = s->next_picture.f.data[1];
384 srcV = s->next_picture.f.data[2];
388 srcY = s->last_picture.f.data[0];
389 srcU = s->last_picture.f.data[1];
390 srcV = s->last_picture.f.data[2];
392 srcY = s->next_picture.f.data[0];
393 srcU = s->next_picture.f.data[1];
394 srcV = s->next_picture.f.data[2];
398 src_x = s->mb_x * 16 + (mx >> 2);
399 src_y = s->mb_y * 16 + (my >> 2);
400 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
401 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
403 if (v->profile != PROFILE_ADVANCED) {
404 src_x = av_clip( src_x, -16, s->mb_width * 16);
405 src_y = av_clip( src_y, -16, s->mb_height * 16);
406 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
407 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
409 src_x = av_clip( src_x, -17, s->avctx->coded_width);
410 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
411 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
412 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
415 srcY += src_y * s->linesize + src_x;
416 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
417 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
419 if (v->field_mode && v->ref_field_type[dir]) {
420 srcY += s->current_picture_ptr->f.linesize[0];
421 srcU += s->current_picture_ptr->f.linesize[1];
422 srcV += s->current_picture_ptr->f.linesize[2];
425 /* for grayscale we should not try to read from unknown area */
426 if (s->flags & CODEC_FLAG_GRAY) {
427 srcU = s->edge_emu_buffer + 18 * s->linesize;
428 srcV = s->edge_emu_buffer + 18 * s->linesize;
431 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
432 || s->h_edge_pos < 22 || v_edge_pos < 22
433 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
434 || (unsigned)(src_y - 1) > v_edge_pos - (my&3) - 16 - 3) {
435 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
437 srcY -= s->mspel * (1 + s->linesize);
438 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
439 17 + s->mspel * 2, 17 + s->mspel * 2,
440 src_x - s->mspel, src_y - s->mspel,
441 s->h_edge_pos, v_edge_pos);
442 srcY = s->edge_emu_buffer;
443 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
444 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
445 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
446 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
449 /* if we deal with range reduction we need to scale source blocks */
450 if (v->rangeredfrm) {
455 for (j = 0; j < 17 + s->mspel * 2; j++) {
456 for (i = 0; i < 17 + s->mspel * 2; i++)
457 src[i] = ((src[i] - 128) >> 1) + 128;
462 for (j = 0; j < 9; j++) {
463 for (i = 0; i < 9; i++) {
464 src[i] = ((src[i] - 128) >> 1) + 128;
465 src2[i] = ((src2[i] - 128) >> 1) + 128;
467 src += s->uvlinesize;
468 src2 += s->uvlinesize;
471 /* if we deal with intensity compensation we need to scale source blocks */
472 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
477 for (j = 0; j < 17 + s->mspel * 2; j++) {
478 for (i = 0; i < 17 + s->mspel * 2; i++)
479 src[i] = v->luty[src[i]];
484 for (j = 0; j < 9; j++) {
485 for (i = 0; i < 9; i++) {
486 src[i] = v->lutuv[src[i]];
487 src2[i] = v->lutuv[src2[i]];
489 src += s->uvlinesize;
490 src2 += s->uvlinesize;
493 srcY += s->mspel * (1 + s->linesize);
496 if (v->field_mode && v->second_field) {
497 off = s->current_picture_ptr->f.linesize[0];
498 off_uv = s->current_picture_ptr->f.linesize[1];
504 dxy = ((my & 3) << 2) | (mx & 3);
505 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
506 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
507 srcY += s->linesize * 8;
508 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
509 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
510 } else { // hpel mc - always used for luma
511 dxy = (my & 2) | ((mx & 2) >> 1);
513 dsp->put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
515 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
518 if (s->flags & CODEC_FLAG_GRAY) return;
519 /* Chroma MC always uses qpel bilinear */
520 uvmx = (uvmx & 3) << 1;
521 uvmy = (uvmy & 3) << 1;
523 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
524 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
526 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
527 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
531 static inline int median4(int a, int b, int c, int d)
534 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
535 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
537 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
538 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
542 /** Do motion compensation for 4-MV macroblock - luminance block
544 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
546 MpegEncContext *s = &v->s;
547 DSPContext *dsp = &v->s.dsp;
549 int dxy, mx, my, src_x, src_y;
551 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
552 int v_edge_pos = s->v_edge_pos >> v->field_mode;
554 if ((!v->field_mode ||
555 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
556 !v->s.last_picture.f.data[0])
559 mx = s->mv[dir][n][0];
560 my = s->mv[dir][n][1];
564 if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field)
565 srcY = s->current_picture.f.data[0];
567 srcY = s->last_picture.f.data[0];
569 srcY = s->last_picture.f.data[0];
571 srcY = s->next_picture.f.data[0];
574 if (v->cur_field_type != v->ref_field_type[dir])
575 my = my - 2 + 4 * v->cur_field_type;
578 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
579 int same_count = 0, opp_count = 0, k;
580 int chosen_mv[2][4][2], f;
582 for (k = 0; k < 4; k++) {
583 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
584 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
585 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
589 f = opp_count > same_count;
590 switch (f ? opp_count : same_count) {
592 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
593 chosen_mv[f][2][0], chosen_mv[f][3][0]);
594 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
595 chosen_mv[f][2][1], chosen_mv[f][3][1]);
598 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
599 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
602 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
603 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
606 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
607 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
608 for (k = 0; k < 4; k++)
609 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
612 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
614 int width = s->avctx->coded_width;
615 int height = s->avctx->coded_height >> 1;
616 qx = (s->mb_x * 16) + (mx >> 2);
617 qy = (s->mb_y * 8) + (my >> 3);
622 mx -= 4 * (qx - width);
625 else if (qy > height + 1)
626 my -= 8 * (qy - height - 1);
629 if ((v->fcm == ILACE_FRAME) && fieldmv)
630 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
632 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
633 if (v->field_mode && v->second_field)
634 off += s->current_picture_ptr->f.linesize[0];
636 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
638 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
640 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
642 if (v->profile != PROFILE_ADVANCED) {
643 src_x = av_clip(src_x, -16, s->mb_width * 16);
644 src_y = av_clip(src_y, -16, s->mb_height * 16);
646 src_x = av_clip(src_x, -17, s->avctx->coded_width);
647 if (v->fcm == ILACE_FRAME) {
649 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
651 src_y = av_clip(src_y, -18, s->avctx->coded_height);
653 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
657 srcY += src_y * s->linesize + src_x;
658 if (v->field_mode && v->ref_field_type[dir])
659 srcY += s->current_picture_ptr->f.linesize[0];
661 if (fieldmv && !(src_y & 1))
663 if (fieldmv && (src_y & 1) && src_y < 4)
665 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
666 || s->h_edge_pos < 13 || v_edge_pos < 23
667 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
668 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
669 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
670 /* check emulate edge stride and offset */
671 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
672 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
673 src_x - s->mspel, src_y - (s->mspel << fieldmv),
674 s->h_edge_pos, v_edge_pos);
675 srcY = s->edge_emu_buffer;
676 /* if we deal with range reduction we need to scale source blocks */
677 if (v->rangeredfrm) {
682 for (j = 0; j < 9 + s->mspel * 2; j++) {
683 for (i = 0; i < 9 + s->mspel * 2; i++)
684 src[i] = ((src[i] - 128) >> 1) + 128;
685 src += s->linesize << fieldmv;
688 /* if we deal with intensity compensation we need to scale source blocks */
689 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
694 for (j = 0; j < 9 + s->mspel * 2; j++) {
695 for (i = 0; i < 9 + s->mspel * 2; i++)
696 src[i] = v->luty[src[i]];
697 src += s->linesize << fieldmv;
700 srcY += s->mspel * (1 + (s->linesize << fieldmv));
704 dxy = ((my & 3) << 2) | (mx & 3);
705 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
706 } else { // hpel mc - always used for luma
707 dxy = (my & 2) | ((mx & 2) >> 1);
709 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
711 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
715 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
718 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
720 idx = ((a[3] != flag) << 3)
721 | ((a[2] != flag) << 2)
722 | ((a[1] != flag) << 1)
725 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
726 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
728 } else if (count[idx] == 1) {
731 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
732 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
735 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
736 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
739 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
740 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
743 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
744 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
747 } else if (count[idx] == 2) {
749 for (i = 0; i < 3; i++)
754 for (i = t1 + 1; i < 4; i++)
759 *tx = (mvx[t1] + mvx[t2]) / 2;
760 *ty = (mvy[t1] + mvy[t2]) / 2;
768 /** Do motion compensation for 4-MV macroblock - both chroma blocks
770 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
772 MpegEncContext *s = &v->s;
773 DSPContext *dsp = &v->s.dsp;
774 uint8_t *srcU, *srcV;
775 int uvmx, uvmy, uvsrc_x, uvsrc_y;
776 int k, tx = 0, ty = 0;
777 int mvx[4], mvy[4], intra[4], mv_f[4];
779 int chroma_ref_type = v->cur_field_type, off = 0;
780 int v_edge_pos = s->v_edge_pos >> v->field_mode;
782 if (!v->field_mode && !v->s.last_picture.f.data[0])
784 if (s->flags & CODEC_FLAG_GRAY)
787 for (k = 0; k < 4; k++) {
788 mvx[k] = s->mv[dir][k][0];
789 mvy[k] = s->mv[dir][k][1];
790 intra[k] = v->mb_type[0][s->block_index[k]];
792 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
795 /* calculate chroma MV vector from four luma MVs */
796 if (!v->field_mode || (v->field_mode && !v->numref)) {
797 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
798 chroma_ref_type = v->reffield;
800 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
801 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
802 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
803 return; //no need to do MC for intra blocks
807 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
809 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
811 chroma_ref_type = !v->cur_field_type;
813 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
815 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
816 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
817 uvmx = (tx + ((tx & 3) == 3)) >> 1;
818 uvmy = (ty + ((ty & 3) == 3)) >> 1;
820 v->luma_mv[s->mb_x][0] = uvmx;
821 v->luma_mv[s->mb_x][1] = uvmy;
824 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
825 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
827 // Field conversion bias
828 if (v->cur_field_type != chroma_ref_type)
829 uvmy += 2 - 4 * chroma_ref_type;
831 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
832 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
834 if (v->profile != PROFILE_ADVANCED) {
835 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
836 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
838 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
839 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
844 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
845 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
846 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
848 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
849 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
852 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
853 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
856 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
857 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
861 if (chroma_ref_type) {
862 srcU += s->current_picture_ptr->f.linesize[1];
863 srcV += s->current_picture_ptr->f.linesize[2];
865 off = v->second_field ? s->current_picture_ptr->f.linesize[1] : 0;
868 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
869 || s->h_edge_pos < 18 || v_edge_pos < 18
870 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
871 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
872 s->dsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
873 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
874 s->h_edge_pos >> 1, v_edge_pos >> 1);
875 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
876 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
877 s->h_edge_pos >> 1, v_edge_pos >> 1);
878 srcU = s->edge_emu_buffer;
879 srcV = s->edge_emu_buffer + 16;
881 /* if we deal with range reduction we need to scale source blocks */
882 if (v->rangeredfrm) {
888 for (j = 0; j < 9; j++) {
889 for (i = 0; i < 9; i++) {
890 src[i] = ((src[i] - 128) >> 1) + 128;
891 src2[i] = ((src2[i] - 128) >> 1) + 128;
893 src += s->uvlinesize;
894 src2 += s->uvlinesize;
897 /* if we deal with intensity compensation we need to scale source blocks */
898 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
904 for (j = 0; j < 9; j++) {
905 for (i = 0; i < 9; i++) {
906 src[i] = v->lutuv[src[i]];
907 src2[i] = v->lutuv[src2[i]];
909 src += s->uvlinesize;
910 src2 += s->uvlinesize;
915 /* Chroma MC always uses qpel bilinear */
916 uvmx = (uvmx & 3) << 1;
917 uvmy = (uvmy & 3) << 1;
919 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
920 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
922 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
923 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
927 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
929 static void vc1_mc_4mv_chroma4(VC1Context *v)
931 MpegEncContext *s = &v->s;
932 DSPContext *dsp = &v->s.dsp;
933 uint8_t *srcU, *srcV;
934 int uvsrc_x, uvsrc_y;
935 int uvmx_field[4], uvmy_field[4];
937 int fieldmv = v->blk_mv_type[s->block_index[0]];
938 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
939 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
940 int v_edge_pos = s->v_edge_pos >> 1;
942 if (!v->s.last_picture.f.data[0])
944 if (s->flags & CODEC_FLAG_GRAY)
947 for (i = 0; i < 4; i++) {
949 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
952 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
954 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
957 for (i = 0; i < 4; i++) {
958 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
959 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
960 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
961 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
962 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
963 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
964 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
965 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
966 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
967 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
969 if (fieldmv && !(uvsrc_y & 1))
971 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
973 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
974 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
975 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
976 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
977 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
978 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
979 s->h_edge_pos >> 1, v_edge_pos);
980 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
981 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
982 s->h_edge_pos >> 1, v_edge_pos);
983 srcU = s->edge_emu_buffer;
984 srcV = s->edge_emu_buffer + 16;
986 /* if we deal with intensity compensation we need to scale source blocks */
987 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
993 for (j = 0; j < 5; j++) {
994 for (i = 0; i < 5; i++) {
995 src[i] = v->lutuv[src[i]];
996 src2[i] = v->lutuv[src2[i]];
998 src += s->uvlinesize << 1;
999 src2 += s->uvlinesize << 1;
1004 dsp->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1005 dsp->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1007 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]);
1008 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]);
1013 /***********************************************************************/
1015 * @name VC-1 Block-level functions
1016 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1022 * @brief Get macroblock-level quantizer scale
1024 #define GET_MQUANT() \
1025 if (v->dquantfrm) { \
1027 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1028 if (v->dqbilevel) { \
1029 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1031 mqdiff = get_bits(gb, 3); \
1033 mquant = v->pq + mqdiff; \
1035 mquant = get_bits(gb, 5); \
1038 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1039 edges = 1 << v->dqsbedge; \
1040 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1041 edges = (3 << v->dqsbedge) % 15; \
1042 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1044 if ((edges&1) && !s->mb_x) \
1045 mquant = v->altpq; \
1046 if ((edges&2) && s->first_slice_line) \
1047 mquant = v->altpq; \
1048 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1049 mquant = v->altpq; \
1050 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1051 mquant = v->altpq; \
1052 if (!mquant || mquant > 31) { \
1053 av_log(v->s.avctx, AV_LOG_ERROR, \
1054 "Overriding invalid mquant %d\n", mquant); \
1060 * @def GET_MVDATA(_dmv_x, _dmv_y)
1061 * @brief Get MV differentials
1062 * @see MVDATA decoding from 8.3.5.2, p(1)20
1063 * @param _dmv_x Horizontal differential for decoded MV
1064 * @param _dmv_y Vertical differential for decoded MV
1066 #define GET_MVDATA(_dmv_x, _dmv_y) \
1067 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1068 VC1_MV_DIFF_VLC_BITS, 2); \
1070 mb_has_coeffs = 1; \
1073 mb_has_coeffs = 0; \
1076 _dmv_x = _dmv_y = 0; \
1077 } else if (index == 35) { \
1078 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1079 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1080 } else if (index == 36) { \
1085 index1 = index % 6; \
1086 if (!s->quarter_sample && index1 == 5) val = 1; \
1088 if (size_table[index1] - val > 0) \
1089 val = get_bits(gb, size_table[index1] - val); \
1091 sign = 0 - (val&1); \
1092 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1094 index1 = index / 6; \
1095 if (!s->quarter_sample && index1 == 5) val = 1; \
1097 if (size_table[index1] - val > 0) \
1098 val = get_bits(gb, size_table[index1] - val); \
1100 sign = 0 - (val & 1); \
1101 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1104 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1105 int *dmv_y, int *pred_flag)
1108 int extend_x = 0, extend_y = 0;
1109 GetBitContext *gb = &v->s.gb;
1112 const int* offs_tab;
1115 bits = VC1_2REF_MVDATA_VLC_BITS;
1118 bits = VC1_1REF_MVDATA_VLC_BITS;
1121 switch (v->dmvrange) {
1129 extend_x = extend_y = 1;
1132 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1134 *dmv_x = get_bits(gb, v->k_x);
1135 *dmv_y = get_bits(gb, v->k_y);
1137 *pred_flag = *dmv_y & 1;
1138 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1142 av_assert0(index < esc);
1144 offs_tab = offset_table2;
1146 offs_tab = offset_table1;
1147 index1 = (index + 1) % 9;
1149 val = get_bits(gb, index1 + extend_x);
1150 sign = 0 -(val & 1);
1151 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1155 offs_tab = offset_table2;
1157 offs_tab = offset_table1;
1158 index1 = (index + 1) / 9;
1159 if (index1 > v->numref) {
1160 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1161 sign = 0 - (val & 1);
1162 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1166 *pred_flag = index1 & 1;
1170 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1172 int scaledvalue, refdist;
1173 int scalesame1, scalesame2;
1174 int scalezone1_x, zone1offset_x;
1175 int table_index = dir ^ v->second_field;
1177 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1178 refdist = v->refdist;
1180 refdist = dir ? v->brfd : v->frfd;
1183 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1184 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1185 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1186 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1191 if (FFABS(n) < scalezone1_x)
1192 scaledvalue = (n * scalesame1) >> 8;
1195 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1197 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1200 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1203 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1205 int scaledvalue, refdist;
1206 int scalesame1, scalesame2;
1207 int scalezone1_y, zone1offset_y;
1208 int table_index = dir ^ v->second_field;
1210 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1211 refdist = v->refdist;
1213 refdist = dir ? v->brfd : v->frfd;
1216 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1217 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1218 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1219 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1224 if (FFABS(n) < scalezone1_y)
1225 scaledvalue = (n * scalesame1) >> 8;
1228 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1230 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1234 if (v->cur_field_type && !v->ref_field_type[dir])
1235 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1237 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1240 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1242 int scalezone1_x, zone1offset_x;
1243 int scaleopp1, scaleopp2, brfd;
1246 brfd = FFMIN(v->brfd, 3);
1247 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1248 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1249 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1250 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1255 if (FFABS(n) < scalezone1_x)
1256 scaledvalue = (n * scaleopp1) >> 8;
1259 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1261 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1264 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1267 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1269 int scalezone1_y, zone1offset_y;
1270 int scaleopp1, scaleopp2, brfd;
1273 brfd = FFMIN(v->brfd, 3);
1274 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1275 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1276 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1277 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1282 if (FFABS(n) < scalezone1_y)
1283 scaledvalue = (n * scaleopp1) >> 8;
1286 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1288 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1291 if (v->cur_field_type && !v->ref_field_type[dir]) {
1292 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1294 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1298 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1301 int brfd, scalesame;
1302 int hpel = 1 - v->s.quarter_sample;
1305 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1307 n = scaleforsame_y(v, i, n, dir) << hpel;
1309 n = scaleforsame_x(v, n, dir) << hpel;
1312 brfd = FFMIN(v->brfd, 3);
1313 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1315 n = (n * scalesame >> 8) << hpel;
1319 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1322 int refdist, scaleopp;
1323 int hpel = 1 - v->s.quarter_sample;
1326 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1328 n = scaleforopp_y(v, n, dir) << hpel;
1330 n = scaleforopp_x(v, n) << hpel;
1333 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1334 refdist = FFMIN(v->refdist, 3);
1336 refdist = dir ? v->brfd : v->frfd;
1337 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1339 n = (n * scaleopp >> 8) << hpel;
1343 /** Predict and set motion vector
1345 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1346 int mv1, int r_x, int r_y, uint8_t* is_intra,
1347 int pred_flag, int dir)
1349 MpegEncContext *s = &v->s;
1350 int xy, wrap, off = 0;
1354 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1355 int opposite, a_f, b_f, c_f;
1356 int16_t field_predA[2];
1357 int16_t field_predB[2];
1358 int16_t field_predC[2];
1359 int a_valid, b_valid, c_valid;
1360 int hybridmv_thresh, y_bias = 0;
1362 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1363 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1367 /* scale MV difference to be quad-pel */
1368 dmv_x <<= 1 - s->quarter_sample;
1369 dmv_y <<= 1 - s->quarter_sample;
1371 wrap = s->b8_stride;
1372 xy = s->block_index[n];
1375 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
1376 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
1377 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
1378 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
1379 if (mv1) { /* duplicate motion data for 1-MV block */
1380 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1381 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1382 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1383 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1384 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1385 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1386 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1387 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1388 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1389 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1390 s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1391 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1392 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1397 C = s->current_picture.f.motion_val[dir][xy - 1 + v->blocks_off];
1398 A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
1400 if (v->field_mode && mixedmv_pic)
1401 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1403 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1405 //in 4-MV mode different blocks have different B predictor position
1408 off = (s->mb_x > 0) ? -1 : 1;
1411 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1420 B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
1422 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1423 b_valid = a_valid && (s->mb_width > 1);
1424 c_valid = s->mb_x || (n == 1 || n == 3);
1425 if (v->field_mode) {
1426 a_valid = a_valid && !is_intra[xy - wrap];
1427 b_valid = b_valid && !is_intra[xy - wrap + off];
1428 c_valid = c_valid && !is_intra[xy - 1];
1432 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1433 num_oppfield += a_f;
1434 num_samefield += 1 - a_f;
1435 field_predA[0] = A[0];
1436 field_predA[1] = A[1];
1438 field_predA[0] = field_predA[1] = 0;
1442 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1443 num_oppfield += b_f;
1444 num_samefield += 1 - b_f;
1445 field_predB[0] = B[0];
1446 field_predB[1] = B[1];
1448 field_predB[0] = field_predB[1] = 0;
1452 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1453 num_oppfield += c_f;
1454 num_samefield += 1 - c_f;
1455 field_predC[0] = C[0];
1456 field_predC[1] = C[1];
1458 field_predC[0] = field_predC[1] = 0;
1462 if (v->field_mode) {
1464 // REFFIELD determines if the last field or the second-last field is
1465 // to be used as reference
1466 opposite = 1 - v->reffield;
1468 if (num_samefield <= num_oppfield)
1469 opposite = 1 - pred_flag;
1471 opposite = pred_flag;
1476 if (a_valid && !a_f) {
1477 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1478 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1480 if (b_valid && !b_f) {
1481 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1482 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1484 if (c_valid && !c_f) {
1485 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1486 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1488 v->mv_f[dir][xy + v->blocks_off] = 1;
1489 v->ref_field_type[dir] = !v->cur_field_type;
1491 if (a_valid && a_f) {
1492 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1493 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1495 if (b_valid && b_f) {
1496 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1497 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1499 if (c_valid && c_f) {
1500 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1501 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1503 v->mv_f[dir][xy + v->blocks_off] = 0;
1504 v->ref_field_type[dir] = v->cur_field_type;
1508 px = field_predA[0];
1509 py = field_predA[1];
1510 } else if (c_valid) {
1511 px = field_predC[0];
1512 py = field_predC[1];
1513 } else if (b_valid) {
1514 px = field_predB[0];
1515 py = field_predB[1];
1521 if (num_samefield + num_oppfield > 1) {
1522 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1523 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1526 /* Pullback MV as specified in 8.3.5.3.4 */
1527 if (!v->field_mode) {
1529 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1530 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1531 X = (s->mb_width << 6) - 4;
1532 Y = (s->mb_height << 6) - 4;
1534 if (qx + px < -60) px = -60 - qx;
1535 if (qy + py < -60) py = -60 - qy;
1537 if (qx + px < -28) px = -28 - qx;
1538 if (qy + py < -28) py = -28 - qy;
1540 if (qx + px > X) px = X - qx;
1541 if (qy + py > Y) py = Y - qy;
1544 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1545 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1546 hybridmv_thresh = 32;
1547 if (a_valid && c_valid) {
1548 if (is_intra[xy - wrap])
1549 sum = FFABS(px) + FFABS(py);
1551 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1552 if (sum > hybridmv_thresh) {
1553 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1554 px = field_predA[0];
1555 py = field_predA[1];
1557 px = field_predC[0];
1558 py = field_predC[1];
1561 if (is_intra[xy - 1])
1562 sum = FFABS(px) + FFABS(py);
1564 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1565 if (sum > hybridmv_thresh) {
1566 if (get_bits1(&s->gb)) {
1567 px = field_predA[0];
1568 py = field_predA[1];
1570 px = field_predC[0];
1571 py = field_predC[1];
1578 if (v->field_mode && v->numref)
1580 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1582 /* store MV using signed modulus of MV range defined in 4.11 */
1583 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;
1584 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;
1585 if (mv1) { /* duplicate motion data for 1-MV block */
1586 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];
1587 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];
1588 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];
1589 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];
1590 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];
1591 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];
1592 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1593 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];
1597 /** Predict and set motion vector for interlaced frame picture MBs
1599 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1600 int mvn, int r_x, int r_y, uint8_t* is_intra)
1602 MpegEncContext *s = &v->s;
1603 int xy, wrap, off = 0;
1604 int A[2], B[2], C[2];
1606 int a_valid = 0, b_valid = 0, c_valid = 0;
1607 int field_a, field_b, field_c; // 0: same, 1: opposit
1608 int total_valid, num_samefield, num_oppfield;
1609 int pos_c, pos_b, n_adj;
1611 wrap = s->b8_stride;
1612 xy = s->block_index[n];
1615 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
1616 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
1617 s->current_picture.f.motion_val[1][xy][0] = 0;
1618 s->current_picture.f.motion_val[1][xy][1] = 0;
1619 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1620 s->current_picture.f.motion_val[0][xy + 1][0] = 0;
1621 s->current_picture.f.motion_val[0][xy + 1][1] = 0;
1622 s->current_picture.f.motion_val[0][xy + wrap][0] = 0;
1623 s->current_picture.f.motion_val[0][xy + wrap][1] = 0;
1624 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
1625 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
1626 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1627 s->current_picture.f.motion_val[1][xy + 1][0] = 0;
1628 s->current_picture.f.motion_val[1][xy + 1][1] = 0;
1629 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1630 s->current_picture.f.motion_val[1][xy + wrap][1] = 0;
1631 s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
1632 s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
1637 off = ((n == 0) || (n == 1)) ? 1 : -1;
1639 if (s->mb_x || (n == 1) || (n == 3)) {
1640 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1641 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1642 A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
1643 A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
1645 } else { // current block has frame mv and cand. has field MV (so average)
1646 A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
1647 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1648 A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
1649 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1652 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1658 /* Predict B and C */
1659 B[0] = B[1] = C[0] = C[1] = 0;
1660 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1661 if (!s->first_slice_line) {
1662 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1665 pos_b = s->block_index[n_adj] - 2 * wrap;
1666 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1667 n_adj = (n & 2) | (n & 1);
1669 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1670 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1671 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1672 B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1673 B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1676 if (s->mb_width > 1) {
1677 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1680 pos_c = s->block_index[2] - 2 * wrap + 2;
1681 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1684 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1685 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1686 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1687 C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1688 C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1690 if (s->mb_x == s->mb_width - 1) {
1691 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1694 pos_c = s->block_index[3] - 2 * wrap - 2;
1695 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1698 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1699 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1700 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1701 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1702 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1711 pos_b = s->block_index[1];
1713 B[0] = s->current_picture.f.motion_val[0][pos_b][0];
1714 B[1] = s->current_picture.f.motion_val[0][pos_b][1];
1715 pos_c = s->block_index[0];
1717 C[0] = s->current_picture.f.motion_val[0][pos_c][0];
1718 C[1] = s->current_picture.f.motion_val[0][pos_c][1];
1721 total_valid = a_valid + b_valid + c_valid;
1722 // check if predictor A is out of bounds
1723 if (!s->mb_x && !(n == 1 || n == 3)) {
1726 // check if predictor B is out of bounds
1727 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1728 B[0] = B[1] = C[0] = C[1] = 0;
1730 if (!v->blk_mv_type[xy]) {
1731 if (s->mb_width == 1) {
1735 if (total_valid >= 2) {
1736 px = mid_pred(A[0], B[0], C[0]);
1737 py = mid_pred(A[1], B[1], C[1]);
1738 } else if (total_valid) {
1739 if (a_valid) { px = A[0]; py = A[1]; }
1740 if (b_valid) { px = B[0]; py = B[1]; }
1741 if (c_valid) { px = C[0]; py = C[1]; }
1747 field_a = (A[1] & 4) ? 1 : 0;
1751 field_b = (B[1] & 4) ? 1 : 0;
1755 field_c = (C[1] & 4) ? 1 : 0;
1759 num_oppfield = field_a + field_b + field_c;
1760 num_samefield = total_valid - num_oppfield;
1761 if (total_valid == 3) {
1762 if ((num_samefield == 3) || (num_oppfield == 3)) {
1763 px = mid_pred(A[0], B[0], C[0]);
1764 py = mid_pred(A[1], B[1], C[1]);
1765 } else if (num_samefield >= num_oppfield) {
1766 /* take one MV from same field set depending on priority
1767 the check for B may not be necessary */
1768 px = !field_a ? A[0] : B[0];
1769 py = !field_a ? A[1] : B[1];
1771 px = field_a ? A[0] : B[0];
1772 py = field_a ? A[1] : B[1];
1774 } else if (total_valid == 2) {
1775 if (num_samefield >= num_oppfield) {
1776 if (!field_a && a_valid) {
1779 } else if (!field_b && b_valid) {
1782 } else if (c_valid) {
1787 if (field_a && a_valid) {
1790 } else if (field_b && b_valid) {
1793 } else if (c_valid) {
1798 } else if (total_valid == 1) {
1799 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1800 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1805 /* store MV using signed modulus of MV range defined in 4.11 */
1806 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;
1807 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;
1808 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1809 s->current_picture.f.motion_val[0][xy + 1 ][0] = s->current_picture.f.motion_val[0][xy][0];
1810 s->current_picture.f.motion_val[0][xy + 1 ][1] = s->current_picture.f.motion_val[0][xy][1];
1811 s->current_picture.f.motion_val[0][xy + wrap ][0] = s->current_picture.f.motion_val[0][xy][0];
1812 s->current_picture.f.motion_val[0][xy + wrap ][1] = s->current_picture.f.motion_val[0][xy][1];
1813 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1814 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1815 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1816 s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1817 s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1818 s->mv[0][n + 1][0] = s->mv[0][n][0];
1819 s->mv[0][n + 1][1] = s->mv[0][n][1];
1823 /** Motion compensation for direct or interpolated blocks in B-frames
1825 static void vc1_interp_mc(VC1Context *v)
1827 MpegEncContext *s = &v->s;
1828 DSPContext *dsp = &v->s.dsp;
1829 uint8_t *srcY, *srcU, *srcV;
1830 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1832 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1834 if (!v->field_mode && !v->s.next_picture.f.data[0])
1837 mx = s->mv[1][0][0];
1838 my = s->mv[1][0][1];
1839 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1840 uvmy = (my + ((my & 3) == 3)) >> 1;
1841 if (v->field_mode) {
1842 if (v->cur_field_type != v->ref_field_type[1])
1843 my = my - 2 + 4 * v->cur_field_type;
1844 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1847 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1848 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1850 srcY = s->next_picture.f.data[0];
1851 srcU = s->next_picture.f.data[1];
1852 srcV = s->next_picture.f.data[2];
1854 src_x = s->mb_x * 16 + (mx >> 2);
1855 src_y = s->mb_y * 16 + (my >> 2);
1856 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1857 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1859 if (v->profile != PROFILE_ADVANCED) {
1860 src_x = av_clip( src_x, -16, s->mb_width * 16);
1861 src_y = av_clip( src_y, -16, s->mb_height * 16);
1862 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1863 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1865 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1866 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1867 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1868 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1871 srcY += src_y * s->linesize + src_x;
1872 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1873 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1875 if (v->field_mode && v->ref_field_type[1]) {
1876 srcY += s->current_picture_ptr->f.linesize[0];
1877 srcU += s->current_picture_ptr->f.linesize[1];
1878 srcV += s->current_picture_ptr->f.linesize[2];
1881 /* for grayscale we should not try to read from unknown area */
1882 if (s->flags & CODEC_FLAG_GRAY) {
1883 srcU = s->edge_emu_buffer + 18 * s->linesize;
1884 srcV = s->edge_emu_buffer + 18 * s->linesize;
1887 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1888 || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1889 || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1890 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1892 srcY -= s->mspel * (1 + s->linesize);
1893 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1894 17 + s->mspel * 2, 17 + s->mspel * 2,
1895 src_x - s->mspel, src_y - s->mspel,
1896 s->h_edge_pos, v_edge_pos);
1897 srcY = s->edge_emu_buffer;
1898 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1899 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1900 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1901 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1904 /* if we deal with range reduction we need to scale source blocks */
1905 if (v->rangeredfrm) {
1907 uint8_t *src, *src2;
1910 for (j = 0; j < 17 + s->mspel * 2; j++) {
1911 for (i = 0; i < 17 + s->mspel * 2; i++)
1912 src[i] = ((src[i] - 128) >> 1) + 128;
1917 for (j = 0; j < 9; j++) {
1918 for (i = 0; i < 9; i++) {
1919 src[i] = ((src[i] - 128) >> 1) + 128;
1920 src2[i] = ((src2[i] - 128) >> 1) + 128;
1922 src += s->uvlinesize;
1923 src2 += s->uvlinesize;
1926 srcY += s->mspel * (1 + s->linesize);
1929 if (v->field_mode && v->second_field) {
1930 off = s->current_picture_ptr->f.linesize[0];
1931 off_uv = s->current_picture_ptr->f.linesize[1];
1938 dxy = ((my & 3) << 2) | (mx & 3);
1939 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
1940 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1941 srcY += s->linesize * 8;
1942 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
1943 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1945 dxy = (my & 2) | ((mx & 2) >> 1);
1948 dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1950 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1953 if (s->flags & CODEC_FLAG_GRAY) return;
1954 /* Chroma MC always uses qpel blilinear */
1955 uvmx = (uvmx & 3) << 1;
1956 uvmy = (uvmy & 3) << 1;
1958 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1959 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1961 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1962 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1966 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1970 #if B_FRACTION_DEN==256
1974 return 2 * ((value * n + 255) >> 9);
1975 return (value * n + 128) >> 8;
1978 n -= B_FRACTION_DEN;
1980 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1981 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1985 /** Reconstruct motion vector for B-frame and do motion compensation
1987 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
1988 int direct, int mode)
1991 v->mv_mode2 = v->mv_mode;
1992 v->mv_mode = MV_PMODE_INTENSITY_COMP;
1998 v->mv_mode = v->mv_mode2;
2001 if (mode == BMV_TYPE_INTERPOLATED) {
2005 v->mv_mode = v->mv_mode2;
2009 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2010 v->mv_mode = v->mv_mode2;
2011 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2013 v->mv_mode = v->mv_mode2;
2016 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2017 int direct, int mvtype)
2019 MpegEncContext *s = &v->s;
2020 int xy, wrap, off = 0;
2025 const uint8_t *is_intra = v->mb_type[0];
2029 /* scale MV difference to be quad-pel */
2030 dmv_x[0] <<= 1 - s->quarter_sample;
2031 dmv_y[0] <<= 1 - s->quarter_sample;
2032 dmv_x[1] <<= 1 - s->quarter_sample;
2033 dmv_y[1] <<= 1 - s->quarter_sample;
2035 wrap = s->b8_stride;
2036 xy = s->block_index[0];
2039 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
2040 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
2041 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
2042 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
2045 if (!v->field_mode) {
2046 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2047 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2048 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2049 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2051 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2052 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));
2053 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));
2054 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));
2055 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));
2058 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2059 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2060 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2061 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2065 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2066 C = s->current_picture.f.motion_val[0][xy - 2];
2067 A = s->current_picture.f.motion_val[0][xy - wrap * 2];
2068 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2069 B = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
2071 if (!s->mb_x) C[0] = C[1] = 0;
2072 if (!s->first_slice_line) { // predictor A is not out of bounds
2073 if (s->mb_width == 1) {
2077 px = mid_pred(A[0], B[0], C[0]);
2078 py = mid_pred(A[1], B[1], C[1]);
2080 } else if (s->mb_x) { // predictor C is not out of bounds
2086 /* Pullback MV as specified in 8.3.5.3.4 */
2089 if (v->profile < PROFILE_ADVANCED) {
2090 qx = (s->mb_x << 5);
2091 qy = (s->mb_y << 5);
2092 X = (s->mb_width << 5) - 4;
2093 Y = (s->mb_height << 5) - 4;
2094 if (qx + px < -28) px = -28 - qx;
2095 if (qy + py < -28) py = -28 - qy;
2096 if (qx + px > X) px = X - qx;
2097 if (qy + py > Y) py = Y - qy;
2099 qx = (s->mb_x << 6);
2100 qy = (s->mb_y << 6);
2101 X = (s->mb_width << 6) - 4;
2102 Y = (s->mb_height << 6) - 4;
2103 if (qx + px < -60) px = -60 - qx;
2104 if (qy + py < -60) py = -60 - qy;
2105 if (qx + px > X) px = X - qx;
2106 if (qy + py > Y) py = Y - qy;
2109 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2110 if (0 && !s->first_slice_line && s->mb_x) {
2111 if (is_intra[xy - wrap])
2112 sum = FFABS(px) + FFABS(py);
2114 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2116 if (get_bits1(&s->gb)) {
2124 if (is_intra[xy - 2])
2125 sum = FFABS(px) + FFABS(py);
2127 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2129 if (get_bits1(&s->gb)) {
2139 /* store MV using signed modulus of MV range defined in 4.11 */
2140 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2141 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2143 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2144 C = s->current_picture.f.motion_val[1][xy - 2];
2145 A = s->current_picture.f.motion_val[1][xy - wrap * 2];
2146 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2147 B = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
2151 if (!s->first_slice_line) { // predictor A is not out of bounds
2152 if (s->mb_width == 1) {
2156 px = mid_pred(A[0], B[0], C[0]);
2157 py = mid_pred(A[1], B[1], C[1]);
2159 } else if (s->mb_x) { // predictor C is not out of bounds
2165 /* Pullback MV as specified in 8.3.5.3.4 */
2168 if (v->profile < PROFILE_ADVANCED) {
2169 qx = (s->mb_x << 5);
2170 qy = (s->mb_y << 5);
2171 X = (s->mb_width << 5) - 4;
2172 Y = (s->mb_height << 5) - 4;
2173 if (qx + px < -28) px = -28 - qx;
2174 if (qy + py < -28) py = -28 - qy;
2175 if (qx + px > X) px = X - qx;
2176 if (qy + py > Y) py = Y - qy;
2178 qx = (s->mb_x << 6);
2179 qy = (s->mb_y << 6);
2180 X = (s->mb_width << 6) - 4;
2181 Y = (s->mb_height << 6) - 4;
2182 if (qx + px < -60) px = -60 - qx;
2183 if (qy + py < -60) py = -60 - qy;
2184 if (qx + px > X) px = X - qx;
2185 if (qy + py > Y) py = Y - qy;
2188 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2189 if (0 && !s->first_slice_line && s->mb_x) {
2190 if (is_intra[xy - wrap])
2191 sum = FFABS(px) + FFABS(py);
2193 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2195 if (get_bits1(&s->gb)) {
2203 if (is_intra[xy - 2])
2204 sum = FFABS(px) + FFABS(py);
2206 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2208 if (get_bits1(&s->gb)) {
2218 /* store MV using signed modulus of MV range defined in 4.11 */
2220 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2221 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2223 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
2224 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
2225 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
2226 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
2229 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2231 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2232 MpegEncContext *s = &v->s;
2233 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2235 if (v->bmvtype == BMV_TYPE_DIRECT) {
2236 int total_opp, k, f;
2237 if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2238 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2239 v->bfraction, 0, s->quarter_sample);
2240 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2241 v->bfraction, 0, s->quarter_sample);
2242 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2243 v->bfraction, 1, s->quarter_sample);
2244 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2245 v->bfraction, 1, s->quarter_sample);
2247 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2248 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2249 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2250 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2251 f = (total_opp > 2) ? 1 : 0;
2253 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2254 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2257 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2258 for (k = 0; k < 4; k++) {
2259 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2260 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2261 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2262 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2263 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2264 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2268 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2269 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);
2270 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);
2273 if (dir) { // backward
2274 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);
2275 if (n == 3 || mv1) {
2276 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2279 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);
2280 if (n == 3 || mv1) {
2281 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2286 /** Get predicted DC value for I-frames only
2287 * prediction dir: left=0, top=1
2288 * @param s MpegEncContext
2289 * @param overlap flag indicating that overlap filtering is used
2290 * @param pq integer part of picture quantizer
2291 * @param[in] n block index in the current MB
2292 * @param dc_val_ptr Pointer to DC predictor
2293 * @param dir_ptr Prediction direction for use in AC prediction
2295 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2296 int16_t **dc_val_ptr, int *dir_ptr)
2298 int a, b, c, wrap, pred, scale;
2300 static const uint16_t dcpred[32] = {
2301 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2302 114, 102, 93, 85, 79, 73, 68, 64,
2303 60, 57, 54, 51, 49, 47, 45, 43,
2304 41, 39, 38, 37, 35, 34, 33
2307 /* find prediction - wmv3_dc_scale always used here in fact */
2308 if (n < 4) scale = s->y_dc_scale;
2309 else scale = s->c_dc_scale;
2311 wrap = s->block_wrap[n];
2312 dc_val = s->dc_val[0] + s->block_index[n];
2318 b = dc_val[ - 1 - wrap];
2319 a = dc_val[ - wrap];
2321 if (pq < 9 || !overlap) {
2322 /* Set outer values */
2323 if (s->first_slice_line && (n != 2 && n != 3))
2324 b = a = dcpred[scale];
2325 if (s->mb_x == 0 && (n != 1 && n != 3))
2326 b = c = dcpred[scale];
2328 /* Set outer values */
2329 if (s->first_slice_line && (n != 2 && n != 3))
2331 if (s->mb_x == 0 && (n != 1 && n != 3))
2335 if (abs(a - b) <= abs(b - c)) {
2337 *dir_ptr = 1; // left
2340 *dir_ptr = 0; // top
2343 /* update predictor */
2344 *dc_val_ptr = &dc_val[0];
2349 /** Get predicted DC value
2350 * prediction dir: left=0, top=1
2351 * @param s MpegEncContext
2352 * @param overlap flag indicating that overlap filtering is used
2353 * @param pq integer part of picture quantizer
2354 * @param[in] n block index in the current MB
2355 * @param a_avail flag indicating top block availability
2356 * @param c_avail flag indicating left block availability
2357 * @param dc_val_ptr Pointer to DC predictor
2358 * @param dir_ptr Prediction direction for use in AC prediction
2360 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2361 int a_avail, int c_avail,
2362 int16_t **dc_val_ptr, int *dir_ptr)
2364 int a, b, c, wrap, pred;
2366 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2370 wrap = s->block_wrap[n];
2371 dc_val = s->dc_val[0] + s->block_index[n];
2377 b = dc_val[ - 1 - wrap];
2378 a = dc_val[ - wrap];
2379 /* scale predictors if needed */
2380 q1 = s->current_picture.f.qscale_table[mb_pos];
2381 dqscale_index = s->y_dc_scale_table[q1] - 1;
2382 if (dqscale_index < 0)
2384 if (c_avail && (n != 1 && n != 3)) {
2385 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2387 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2389 if (a_avail && (n != 2 && n != 3)) {
2390 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2392 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2394 if (a_avail && c_avail && (n != 3)) {
2399 off -= s->mb_stride;
2400 q2 = s->current_picture.f.qscale_table[off];
2402 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2405 if (a_avail && c_avail) {
2406 if (abs(a - b) <= abs(b - c)) {
2408 *dir_ptr = 1; // left
2411 *dir_ptr = 0; // top
2413 } else if (a_avail) {
2415 *dir_ptr = 0; // top
2416 } else if (c_avail) {
2418 *dir_ptr = 1; // left
2421 *dir_ptr = 1; // left
2424 /* update predictor */
2425 *dc_val_ptr = &dc_val[0];
2429 /** @} */ // Block group
2432 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2433 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2437 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2438 uint8_t **coded_block_ptr)
2440 int xy, wrap, pred, a, b, c;
2442 xy = s->block_index[n];
2443 wrap = s->b8_stride;
2448 a = s->coded_block[xy - 1 ];
2449 b = s->coded_block[xy - 1 - wrap];
2450 c = s->coded_block[xy - wrap];
2459 *coded_block_ptr = &s->coded_block[xy];
2465 * Decode one AC coefficient
2466 * @param v The VC1 context
2467 * @param last Last coefficient
2468 * @param skip How much zero coefficients to skip
2469 * @param value Decoded AC coefficient value
2470 * @param codingset set of VLC to decode data
2473 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2474 int *value, int codingset)
2476 GetBitContext *gb = &v->s.gb;
2477 int index, escape, run = 0, level = 0, lst = 0;
2479 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2480 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2481 run = vc1_index_decode_table[codingset][index][0];
2482 level = vc1_index_decode_table[codingset][index][1];
2483 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2487 escape = decode210(gb);
2489 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2490 run = vc1_index_decode_table[codingset][index][0];
2491 level = vc1_index_decode_table[codingset][index][1];
2492 lst = index >= vc1_last_decode_table[codingset];
2495 level += vc1_last_delta_level_table[codingset][run];
2497 level += vc1_delta_level_table[codingset][run];
2500 run += vc1_last_delta_run_table[codingset][level] + 1;
2502 run += vc1_delta_run_table[codingset][level] + 1;
2508 lst = get_bits1(gb);
2509 if (v->s.esc3_level_length == 0) {
2510 if (v->pq < 8 || v->dquantfrm) { // table 59
2511 v->s.esc3_level_length = get_bits(gb, 3);
2512 if (!v->s.esc3_level_length)
2513 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2514 } else { // table 60
2515 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2517 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2519 run = get_bits(gb, v->s.esc3_run_length);
2520 sign = get_bits1(gb);
2521 level = get_bits(gb, v->s.esc3_level_length);
2532 /** Decode intra block in intra frames - should be faster than decode_intra_block
2533 * @param v VC1Context
2534 * @param block block to decode
2535 * @param[in] n subblock index
2536 * @param coded are AC coeffs present or not
2537 * @param codingset set of VLC to decode data
2539 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
2540 int coded, int codingset)
2542 GetBitContext *gb = &v->s.gb;
2543 MpegEncContext *s = &v->s;
2544 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2547 int16_t *ac_val, *ac_val2;
2550 /* Get DC differential */
2552 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2554 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2557 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2561 if (dcdiff == 119 /* ESC index value */) {
2562 /* TODO: Optimize */
2563 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2564 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2565 else dcdiff = get_bits(gb, 8);
2568 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2569 else if (v->pq == 2)
2570 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2577 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2580 /* Store the quantized DC coeff, used for prediction */
2582 block[0] = dcdiff * s->y_dc_scale;
2584 block[0] = dcdiff * s->c_dc_scale;
2595 int last = 0, skip, value;
2596 const uint8_t *zz_table;
2600 scale = v->pq * 2 + v->halfpq;
2604 zz_table = v->zz_8x8[2];
2606 zz_table = v->zz_8x8[3];
2608 zz_table = v->zz_8x8[1];
2610 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2612 if (dc_pred_dir) // left
2615 ac_val -= 16 * s->block_wrap[n];
2618 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2622 block[zz_table[i++]] = value;
2625 /* apply AC prediction if needed */
2627 if (dc_pred_dir) { // left
2628 for (k = 1; k < 8; k++)
2629 block[k << v->left_blk_sh] += ac_val[k];
2631 for (k = 1; k < 8; k++)
2632 block[k << v->top_blk_sh] += ac_val[k + 8];
2635 /* save AC coeffs for further prediction */
2636 for (k = 1; k < 8; k++) {
2637 ac_val2[k] = block[k << v->left_blk_sh];
2638 ac_val2[k + 8] = block[k << v->top_blk_sh];
2641 /* scale AC coeffs */
2642 for (k = 1; k < 64; k++)
2646 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2649 if (s->ac_pred) i = 63;
2655 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2659 scale = v->pq * 2 + v->halfpq;
2660 memset(ac_val2, 0, 16 * 2);
2661 if (dc_pred_dir) { // left
2664 memcpy(ac_val2, ac_val, 8 * 2);
2666 ac_val -= 16 * s->block_wrap[n];
2668 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2671 /* apply AC prediction if needed */
2673 if (dc_pred_dir) { //left
2674 for (k = 1; k < 8; k++) {
2675 block[k << v->left_blk_sh] = ac_val[k] * scale;
2676 if (!v->pquantizer && block[k << v->left_blk_sh])
2677 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2680 for (k = 1; k < 8; k++) {
2681 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2682 if (!v->pquantizer && block[k << v->top_blk_sh])
2683 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2689 s->block_last_index[n] = i;
2694 /** Decode intra block in intra frames - should be faster than decode_intra_block
2695 * @param v VC1Context
2696 * @param block block to decode
2697 * @param[in] n subblock number
2698 * @param coded are AC coeffs present or not
2699 * @param codingset set of VLC to decode data
2700 * @param mquant quantizer value for this macroblock
2702 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
2703 int coded, int codingset, int mquant)
2705 GetBitContext *gb = &v->s.gb;
2706 MpegEncContext *s = &v->s;
2707 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2710 int16_t *ac_val, *ac_val2;
2712 int a_avail = v->a_avail, c_avail = v->c_avail;
2713 int use_pred = s->ac_pred;
2716 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2718 /* Get DC differential */
2720 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2722 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2725 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2729 if (dcdiff == 119 /* ESC index value */) {
2730 /* TODO: Optimize */
2731 if (mquant == 1) dcdiff = get_bits(gb, 10);
2732 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2733 else dcdiff = get_bits(gb, 8);
2736 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2737 else if (mquant == 2)
2738 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2745 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2748 /* Store the quantized DC coeff, used for prediction */
2750 block[0] = dcdiff * s->y_dc_scale;
2752 block[0] = dcdiff * s->c_dc_scale;
2758 /* check if AC is needed at all */
2759 if (!a_avail && !c_avail)
2761 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2764 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2766 if (dc_pred_dir) // left
2769 ac_val -= 16 * s->block_wrap[n];
2771 q1 = s->current_picture.f.qscale_table[mb_pos];
2772 if ( dc_pred_dir && c_avail && mb_pos)
2773 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2774 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2775 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2776 if ( dc_pred_dir && n == 1)
2778 if (!dc_pred_dir && n == 2)
2784 int last = 0, skip, value;
2785 const uint8_t *zz_table;
2789 if (!use_pred && v->fcm == ILACE_FRAME) {
2790 zz_table = v->zzi_8x8;
2792 if (!dc_pred_dir) // top
2793 zz_table = v->zz_8x8[2];
2795 zz_table = v->zz_8x8[3];
2798 if (v->fcm != ILACE_FRAME)
2799 zz_table = v->zz_8x8[1];
2801 zz_table = v->zzi_8x8;
2805 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2809 block[zz_table[i++]] = value;
2812 /* apply AC prediction if needed */
2814 /* scale predictors if needed*/
2815 if (q2 && q1 != q2) {
2816 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2817 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2820 return AVERROR_INVALIDDATA;
2821 if (dc_pred_dir) { // left
2822 for (k = 1; k < 8; k++)
2823 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2825 for (k = 1; k < 8; k++)
2826 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2829 if (dc_pred_dir) { //left
2830 for (k = 1; k < 8; k++)
2831 block[k << v->left_blk_sh] += ac_val[k];
2833 for (k = 1; k < 8; k++)
2834 block[k << v->top_blk_sh] += ac_val[k + 8];
2838 /* save AC coeffs for further prediction */
2839 for (k = 1; k < 8; k++) {
2840 ac_val2[k ] = block[k << v->left_blk_sh];
2841 ac_val2[k + 8] = block[k << v->top_blk_sh];
2844 /* scale AC coeffs */
2845 for (k = 1; k < 64; k++)
2849 block[k] += (block[k] < 0) ? -mquant : mquant;
2852 if (use_pred) i = 63;
2853 } else { // no AC coeffs
2856 memset(ac_val2, 0, 16 * 2);
2857 if (dc_pred_dir) { // left
2859 memcpy(ac_val2, ac_val, 8 * 2);
2860 if (q2 && q1 != q2) {
2861 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2862 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2864 return AVERROR_INVALIDDATA;
2865 for (k = 1; k < 8; k++)
2866 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2871 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2872 if (q2 && q1 != q2) {
2873 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2874 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2876 return AVERROR_INVALIDDATA;
2877 for (k = 1; k < 8; k++)
2878 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2883 /* apply AC prediction if needed */
2885 if (dc_pred_dir) { // left
2886 for (k = 1; k < 8; k++) {
2887 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2888 if (!v->pquantizer && block[k << v->left_blk_sh])
2889 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2892 for (k = 1; k < 8; k++) {
2893 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2894 if (!v->pquantizer && block[k << v->top_blk_sh])
2895 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2901 s->block_last_index[n] = i;
2906 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2907 * @param v VC1Context
2908 * @param block block to decode
2909 * @param[in] n subblock index
2910 * @param coded are AC coeffs present or not
2911 * @param mquant block quantizer
2912 * @param codingset set of VLC to decode data
2914 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
2915 int coded, int mquant, int codingset)
2917 GetBitContext *gb = &v->s.gb;
2918 MpegEncContext *s = &v->s;
2919 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2922 int16_t *ac_val, *ac_val2;
2924 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2925 int a_avail = v->a_avail, c_avail = v->c_avail;
2926 int use_pred = s->ac_pred;
2930 s->dsp.clear_block(block);
2932 /* XXX: Guard against dumb values of mquant */
2933 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2935 /* Set DC scale - y and c use the same */
2936 s->y_dc_scale = s->y_dc_scale_table[mquant];
2937 s->c_dc_scale = s->c_dc_scale_table[mquant];
2939 /* Get DC differential */
2941 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2943 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2946 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2950 if (dcdiff == 119 /* ESC index value */) {
2951 /* TODO: Optimize */
2952 if (mquant == 1) dcdiff = get_bits(gb, 10);
2953 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2954 else dcdiff = get_bits(gb, 8);
2957 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2958 else if (mquant == 2)
2959 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2966 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2969 /* Store the quantized DC coeff, used for prediction */
2972 block[0] = dcdiff * s->y_dc_scale;
2974 block[0] = dcdiff * s->c_dc_scale;
2980 /* check if AC is needed at all and adjust direction if needed */
2981 if (!a_avail) dc_pred_dir = 1;
2982 if (!c_avail) dc_pred_dir = 0;
2983 if (!a_avail && !c_avail) use_pred = 0;
2984 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2987 scale = mquant * 2 + v->halfpq;
2989 if (dc_pred_dir) //left
2992 ac_val -= 16 * s->block_wrap[n];
2994 q1 = s->current_picture.f.qscale_table[mb_pos];
2995 if (dc_pred_dir && c_avail && mb_pos)
2996 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2997 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2998 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2999 if ( dc_pred_dir && n == 1)
3001 if (!dc_pred_dir && n == 2)
3003 if (n == 3) q2 = q1;
3006 int last = 0, skip, value;
3010 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3014 if (v->fcm == PROGRESSIVE)
3015 block[v->zz_8x8[0][i++]] = value;
3017 if (use_pred && (v->fcm == ILACE_FRAME)) {
3018 if (!dc_pred_dir) // top
3019 block[v->zz_8x8[2][i++]] = value;
3021 block[v->zz_8x8[3][i++]] = value;
3023 block[v->zzi_8x8[i++]] = value;
3028 /* apply AC prediction if needed */
3030 /* scale predictors if needed*/
3031 if (q2 && q1 != q2) {
3032 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3033 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3036 return AVERROR_INVALIDDATA;
3037 if (dc_pred_dir) { // left
3038 for (k = 1; k < 8; k++)
3039 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3041 for (k = 1; k < 8; k++)
3042 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3045 if (dc_pred_dir) { // left
3046 for (k = 1; k < 8; k++)
3047 block[k << v->left_blk_sh] += ac_val[k];
3049 for (k = 1; k < 8; k++)
3050 block[k << v->top_blk_sh] += ac_val[k + 8];
3054 /* save AC coeffs for further prediction */
3055 for (k = 1; k < 8; k++) {
3056 ac_val2[k ] = block[k << v->left_blk_sh];
3057 ac_val2[k + 8] = block[k << v->top_blk_sh];
3060 /* scale AC coeffs */
3061 for (k = 1; k < 64; k++)
3065 block[k] += (block[k] < 0) ? -mquant : mquant;
3068 if (use_pred) i = 63;
3069 } else { // no AC coeffs
3072 memset(ac_val2, 0, 16 * 2);
3073 if (dc_pred_dir) { // left
3075 memcpy(ac_val2, ac_val, 8 * 2);
3076 if (q2 && q1 != q2) {
3077 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3078 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3080 return AVERROR_INVALIDDATA;
3081 for (k = 1; k < 8; k++)
3082 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3087 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3088 if (q2 && q1 != q2) {
3089 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3090 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3092 return AVERROR_INVALIDDATA;
3093 for (k = 1; k < 8; k++)
3094 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3099 /* apply AC prediction if needed */
3101 if (dc_pred_dir) { // left
3102 for (k = 1; k < 8; k++) {
3103 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3104 if (!v->pquantizer && block[k << v->left_blk_sh])
3105 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3108 for (k = 1; k < 8; k++) {
3109 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3110 if (!v->pquantizer && block[k << v->top_blk_sh])
3111 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3117 s->block_last_index[n] = i;
3124 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
3125 int mquant, int ttmb, int first_block,
3126 uint8_t *dst, int linesize, int skip_block,
3129 MpegEncContext *s = &v->s;
3130 GetBitContext *gb = &s->gb;
3133 int scale, off, idx, last, skip, value;
3134 int ttblk = ttmb & 7;
3137 s->dsp.clear_block(block);
3140 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)];
3142 if (ttblk == TT_4X4) {
3143 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3145 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3146 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3147 || (!v->res_rtm_flag && !first_block))) {
3148 subblkpat = decode012(gb);
3150 subblkpat ^= 3; // swap decoded pattern bits
3151 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3153 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3156 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3158 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3159 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3160 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3163 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3164 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3173 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3178 idx = v->zz_8x8[0][i++];
3180 idx = v->zzi_8x8[i++];
3181 block[idx] = value * scale;
3183 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3187 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3189 v->vc1dsp.vc1_inv_trans_8x8(block);
3190 s->dsp.add_pixels_clamped(block, dst, linesize);
3195 pat = ~subblkpat & 0xF;
3196 for (j = 0; j < 4; j++) {
3197 last = subblkpat & (1 << (3 - j));
3199 off = (j & 1) * 4 + (j & 2) * 16;
3201 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3206 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3208 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3209 block[idx + off] = value * scale;
3211 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3213 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3215 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3217 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3222 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3223 for (j = 0; j < 2; j++) {
3224 last = subblkpat & (1 << (1 - j));
3228 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3233 idx = v->zz_8x4[i++] + off;
3235 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3236 block[idx] = value * scale;
3238 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3240 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3242 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3244 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3249 pat = ~(subblkpat * 5) & 0xF;
3250 for (j = 0; j < 2; j++) {
3251 last = subblkpat & (1 << (1 - j));
3255 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3260 idx = v->zz_4x8[i++] + off;
3262 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3263 block[idx] = value * scale;
3265 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3267 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3269 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3271 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3277 *ttmb_out |= ttblk << (n * 4);
3281 /** @} */ // Macroblock group
3283 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3284 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3286 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3288 MpegEncContext *s = &v->s;
3289 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3290 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3291 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3292 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3293 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3296 if (block_num > 3) {
3297 dst = s->dest[block_num - 3];
3299 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3301 if (s->mb_y != s->end_mb_y || block_num < 2) {
3305 if (block_num > 3) {
3306 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3307 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3308 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3309 mv_stride = s->mb_stride;
3311 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3312 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3313 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3314 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3315 mv_stride = s->b8_stride;
3316 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3319 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3320 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3321 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3323 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3325 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3328 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3330 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3335 dst -= 4 * linesize;
3336 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3337 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3338 idx = (block_cbp | (block_cbp >> 2)) & 3;
3340 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3343 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3345 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3350 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3352 MpegEncContext *s = &v->s;
3353 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3354 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3355 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3356 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3357 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3360 if (block_num > 3) {
3361 dst = s->dest[block_num - 3] - 8 * linesize;
3363 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3366 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3369 if (block_num > 3) {
3370 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3371 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3372 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3374 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3375 : (mb_cbp >> ((block_num + 1) * 4));
3376 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3377 : (mb_is_intra >> ((block_num + 1) * 4));
3378 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3380 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3381 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3383 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3385 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3388 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3390 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3396 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3397 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3398 idx = (block_cbp | (block_cbp >> 1)) & 5;
3400 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3403 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3405 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3410 static void vc1_apply_p_loop_filter(VC1Context *v)
3412 MpegEncContext *s = &v->s;
3415 for (i = 0; i < 6; i++) {
3416 vc1_apply_p_v_loop_filter(v, i);
3419 /* V always precedes H, therefore we run H one MB before V;
3420 * at the end of a row, we catch up to complete the row */
3422 for (i = 0; i < 6; i++) {
3423 vc1_apply_p_h_loop_filter(v, i);
3425 if (s->mb_x == s->mb_width - 1) {
3427 ff_update_block_index(s);
3428 for (i = 0; i < 6; i++) {
3429 vc1_apply_p_h_loop_filter(v, i);
3435 /** Decode one P-frame MB
3437 static int vc1_decode_p_mb(VC1Context *v)
3439 MpegEncContext *s = &v->s;
3440 GetBitContext *gb = &s->gb;
3442 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3443 int cbp; /* cbp decoding stuff */
3444 int mqdiff, mquant; /* MB quantization */
3445 int ttmb = v->ttfrm; /* MB Transform type */
3447 int mb_has_coeffs = 1; /* last_flag */
3448 int dmv_x, dmv_y; /* Differential MV components */
3449 int index, index1; /* LUT indexes */
3450 int val, sign; /* temp values */
3451 int first_block = 1;
3453 int skipped, fourmv;
3454 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3456 mquant = v->pq; /* lossy initialization */
3458 if (v->mv_type_is_raw)
3459 fourmv = get_bits1(gb);
3461 fourmv = v->mv_type_mb_plane[mb_pos];
3463 skipped = get_bits1(gb);
3465 skipped = v->s.mbskip_table[mb_pos];
3467 if (!fourmv) { /* 1MV mode */
3469 GET_MVDATA(dmv_x, dmv_y);
3472 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3473 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3475 s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3476 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3478 /* FIXME Set DC val for inter block ? */
3479 if (s->mb_intra && !mb_has_coeffs) {
3481 s->ac_pred = get_bits1(gb);
3483 } else if (mb_has_coeffs) {
3485 s->ac_pred = get_bits1(gb);
3486 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3492 s->current_picture.f.qscale_table[mb_pos] = mquant;
3494 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3495 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3496 VC1_TTMB_VLC_BITS, 2);
3497 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3499 for (i = 0; i < 6; i++) {
3500 s->dc_val[0][s->block_index[i]] = 0;
3502 val = ((cbp >> (5 - i)) & 1);
3503 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3504 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3506 /* check if prediction blocks A and C are available */
3507 v->a_avail = v->c_avail = 0;
3508 if (i == 2 || i == 3 || !s->first_slice_line)
3509 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3510 if (i == 1 || i == 3 || s->mb_x)
3511 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3513 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3514 (i & 4) ? v->codingset2 : v->codingset);
3515 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3517 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3519 for (j = 0; j < 64; j++)
3520 s->block[i][j] <<= 1;
3521 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3522 if (v->pq >= 9 && v->overlap) {
3524 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3526 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3528 block_cbp |= 0xF << (i << 2);
3529 block_intra |= 1 << i;
3531 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3532 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3533 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3534 block_cbp |= pat << (i << 2);
3535 if (!v->ttmbf && ttmb < 8)
3542 for (i = 0; i < 6; i++) {
3543 v->mb_type[0][s->block_index[i]] = 0;
3544 s->dc_val[0][s->block_index[i]] = 0;
3546 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3547 s->current_picture.f.qscale_table[mb_pos] = 0;
3548 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3551 } else { // 4MV mode
3552 if (!skipped /* unskipped MB */) {
3553 int intra_count = 0, coded_inter = 0;
3554 int is_intra[6], is_coded[6];
3556 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3557 for (i = 0; i < 6; i++) {
3558 val = ((cbp >> (5 - i)) & 1);
3559 s->dc_val[0][s->block_index[i]] = 0;
3566 GET_MVDATA(dmv_x, dmv_y);
3568 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3570 vc1_mc_4mv_luma(v, i, 0);
3571 intra_count += s->mb_intra;
3572 is_intra[i] = s->mb_intra;
3573 is_coded[i] = mb_has_coeffs;
3576 is_intra[i] = (intra_count >= 3);
3580 vc1_mc_4mv_chroma(v, 0);
3581 v->mb_type[0][s->block_index[i]] = is_intra[i];
3583 coded_inter = !is_intra[i] & is_coded[i];
3585 // if there are no coded blocks then don't do anything more
3587 if (!intra_count && !coded_inter)
3590 s->current_picture.f.qscale_table[mb_pos] = mquant;
3591 /* test if block is intra and has pred */
3594 for (i = 0; i < 6; i++)
3596 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3597 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3603 s->ac_pred = get_bits1(gb);
3607 if (!v->ttmbf && coded_inter)
3608 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3609 for (i = 0; i < 6; i++) {
3611 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3612 s->mb_intra = is_intra[i];
3614 /* check if prediction blocks A and C are available */
3615 v->a_avail = v->c_avail = 0;
3616 if (i == 2 || i == 3 || !s->first_slice_line)
3617 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3618 if (i == 1 || i == 3 || s->mb_x)
3619 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3621 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3622 (i & 4) ? v->codingset2 : v->codingset);
3623 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3625 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3627 for (j = 0; j < 64; j++)
3628 s->block[i][j] <<= 1;
3629 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3630 (i & 4) ? s->uvlinesize : s->linesize);
3631 if (v->pq >= 9 && v->overlap) {
3633 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3635 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3637 block_cbp |= 0xF << (i << 2);
3638 block_intra |= 1 << i;
3639 } else if (is_coded[i]) {
3640 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3641 first_block, s->dest[dst_idx] + off,
3642 (i & 4) ? s->uvlinesize : s->linesize,
3643 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3645 block_cbp |= pat << (i << 2);
3646 if (!v->ttmbf && ttmb < 8)
3651 } else { // skipped MB
3653 s->current_picture.f.qscale_table[mb_pos] = 0;
3654 for (i = 0; i < 6; i++) {
3655 v->mb_type[0][s->block_index[i]] = 0;
3656 s->dc_val[0][s->block_index[i]] = 0;
3658 for (i = 0; i < 4; i++) {
3659 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3660 vc1_mc_4mv_luma(v, i, 0);
3662 vc1_mc_4mv_chroma(v, 0);
3663 s->current_picture.f.qscale_table[mb_pos] = 0;
3667 v->cbp[s->mb_x] = block_cbp;
3668 v->ttblk[s->mb_x] = block_tt;
3669 v->is_intra[s->mb_x] = block_intra;
3674 /* Decode one macroblock in an interlaced frame p picture */
3676 static int vc1_decode_p_mb_intfr(VC1Context *v)
3678 MpegEncContext *s = &v->s;
3679 GetBitContext *gb = &s->gb;
3681 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3682 int cbp = 0; /* cbp decoding stuff */
3683 int mqdiff, mquant; /* MB quantization */
3684 int ttmb = v->ttfrm; /* MB Transform type */
3686 int mb_has_coeffs = 1; /* last_flag */
3687 int dmv_x, dmv_y; /* Differential MV components */
3688 int val; /* temp value */
3689 int first_block = 1;
3691 int skipped, fourmv = 0, twomv = 0;
3692 int block_cbp = 0, pat, block_tt = 0;
3693 int idx_mbmode = 0, mvbp;
3694 int stride_y, fieldtx;
3696 mquant = v->pq; /* Lossy initialization */
3699 skipped = get_bits1(gb);
3701 skipped = v->s.mbskip_table[mb_pos];
3703 if (v->fourmvswitch)
3704 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3706 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3707 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3708 /* store the motion vector type in a flag (useful later) */
3709 case MV_PMODE_INTFR_4MV:
3711 v->blk_mv_type[s->block_index[0]] = 0;
3712 v->blk_mv_type[s->block_index[1]] = 0;
3713 v->blk_mv_type[s->block_index[2]] = 0;
3714 v->blk_mv_type[s->block_index[3]] = 0;
3716 case MV_PMODE_INTFR_4MV_FIELD:
3718 v->blk_mv_type[s->block_index[0]] = 1;
3719 v->blk_mv_type[s->block_index[1]] = 1;
3720 v->blk_mv_type[s->block_index[2]] = 1;
3721 v->blk_mv_type[s->block_index[3]] = 1;
3723 case MV_PMODE_INTFR_2MV_FIELD:
3725 v->blk_mv_type[s->block_index[0]] = 1;
3726 v->blk_mv_type[s->block_index[1]] = 1;
3727 v->blk_mv_type[s->block_index[2]] = 1;
3728 v->blk_mv_type[s->block_index[3]] = 1;
3730 case MV_PMODE_INTFR_1MV:
3731 v->blk_mv_type[s->block_index[0]] = 0;
3732 v->blk_mv_type[s->block_index[1]] = 0;
3733 v->blk_mv_type[s->block_index[2]] = 0;
3734 v->blk_mv_type[s->block_index[3]] = 0;
3737 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3738 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3739 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3740 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
3741 s->mb_intra = v->is_intra[s->mb_x] = 1;
3742 for (i = 0; i < 6; i++)
3743 v->mb_type[0][s->block_index[i]] = 1;
3744 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3745 mb_has_coeffs = get_bits1(gb);
3747 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3748 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3750 s->current_picture.f.qscale_table[mb_pos] = mquant;
3751 /* Set DC scale - y and c use the same (not sure if necessary here) */
3752 s->y_dc_scale = s->y_dc_scale_table[mquant];
3753 s->c_dc_scale = s->c_dc_scale_table[mquant];
3755 for (i = 0; i < 6; i++) {
3756 s->dc_val[0][s->block_index[i]] = 0;
3758 val = ((cbp >> (5 - i)) & 1);
3759 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3760 v->a_avail = v->c_avail = 0;
3761 if (i == 2 || i == 3 || !s->first_slice_line)
3762 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3763 if (i == 1 || i == 3 || s->mb_x)
3764 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3766 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3767 (i & 4) ? v->codingset2 : v->codingset);
3768 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3769 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3771 stride_y = s->linesize << fieldtx;
3772 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3774 stride_y = s->uvlinesize;
3777 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3781 } else { // inter MB
3782 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3784 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3785 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3786 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3788 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3789 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3790 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3793 s->mb_intra = v->is_intra[s->mb_x] = 0;
3794 for (i = 0; i < 6; i++)
3795 v->mb_type[0][s->block_index[i]] = 0;
3796 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3797 /* for all motion vector read MVDATA and motion compensate each block */
3801 for (i = 0; i < 6; i++) {
3804 val = ((mvbp >> (3 - i)) & 1);
3806 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3808 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3809 vc1_mc_4mv_luma(v, i, 0);
3810 } else if (i == 4) {
3811 vc1_mc_4mv_chroma4(v);
3818 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3820 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3821 vc1_mc_4mv_luma(v, 0, 0);
3822 vc1_mc_4mv_luma(v, 1, 0);
3825 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3827 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3828 vc1_mc_4mv_luma(v, 2, 0);
3829 vc1_mc_4mv_luma(v, 3, 0);
3830 vc1_mc_4mv_chroma4(v);
3832 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3835 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3837 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3841 GET_MQUANT(); // p. 227
3842 s->current_picture.f.qscale_table[mb_pos] = mquant;
3843 if (!v->ttmbf && cbp)
3844 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3845 for (i = 0; i < 6; i++) {
3846 s->dc_val[0][s->block_index[i]] = 0;
3848 val = ((cbp >> (5 - i)) & 1);
3850 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3852 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3854 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3855 first_block, s->dest[dst_idx] + off,
3856 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3857 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3858 block_cbp |= pat << (i << 2);
3859 if (!v->ttmbf && ttmb < 8)
3866 s->mb_intra = v->is_intra[s->mb_x] = 0;
3867 for (i = 0; i < 6; i++) {
3868 v->mb_type[0][s->block_index[i]] = 0;
3869 s->dc_val[0][s->block_index[i]] = 0;
3871 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3872 s->current_picture.f.qscale_table[mb_pos] = 0;
3873 v->blk_mv_type[s->block_index[0]] = 0;
3874 v->blk_mv_type[s->block_index[1]] = 0;
3875 v->blk_mv_type[s->block_index[2]] = 0;
3876 v->blk_mv_type[s->block_index[3]] = 0;
3877 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3880 if (s->mb_x == s->mb_width - 1)
3881 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3885 static int vc1_decode_p_mb_intfi(VC1Context *v)
3887 MpegEncContext *s = &v->s;
3888 GetBitContext *gb = &s->gb;
3890 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3891 int cbp = 0; /* cbp decoding stuff */
3892 int mqdiff, mquant; /* MB quantization */
3893 int ttmb = v->ttfrm; /* MB Transform type */
3895 int mb_has_coeffs = 1; /* last_flag */
3896 int dmv_x, dmv_y; /* Differential MV components */
3897 int val; /* temp values */
3898 int first_block = 1;
3901 int block_cbp = 0, pat, block_tt = 0;
3904 mquant = v->pq; /* Lossy initialization */
3906 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3907 if (idx_mbmode <= 1) { // intra MB
3908 s->mb_intra = v->is_intra[s->mb_x] = 1;
3909 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3910 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3911 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3913 s->current_picture.f.qscale_table[mb_pos] = mquant;
3914 /* Set DC scale - y and c use the same (not sure if necessary here) */
3915 s->y_dc_scale = s->y_dc_scale_table[mquant];
3916 s->c_dc_scale = s->c_dc_scale_table[mquant];
3917 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3918 mb_has_coeffs = idx_mbmode & 1;
3920 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3922 for (i = 0; i < 6; i++) {
3923 s->dc_val[0][s->block_index[i]] = 0;
3924 v->mb_type[0][s->block_index[i]] = 1;
3926 val = ((cbp >> (5 - i)) & 1);
3927 v->a_avail = v->c_avail = 0;
3928 if (i == 2 || i == 3 || !s->first_slice_line)
3929 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3930 if (i == 1 || i == 3 || s->mb_x)
3931 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3933 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3934 (i & 4) ? v->codingset2 : v->codingset);
3935 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3937 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3938 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3939 off += v->second_field ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
3940 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
3941 // TODO: loop filter
3944 s->mb_intra = v->is_intra[s->mb_x] = 0;
3945 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3946 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3947 if (idx_mbmode <= 5) { // 1-MV
3948 dmv_x = dmv_y = pred_flag = 0;
3949 if (idx_mbmode & 1) {
3950 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3952 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3954 mb_has_coeffs = !(idx_mbmode & 2);
3956 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3957 for (i = 0; i < 6; i++) {
3959 dmv_x = dmv_y = pred_flag = 0;
3960 val = ((v->fourmvbp >> (3 - i)) & 1);
3962 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3964 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3965 vc1_mc_4mv_luma(v, i, 0);
3967 vc1_mc_4mv_chroma(v, 0);
3969 mb_has_coeffs = idx_mbmode & 1;
3972 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3976 s->current_picture.f.qscale_table[mb_pos] = mquant;
3977 if (!v->ttmbf && cbp) {
3978 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3981 for (i = 0; i < 6; i++) {
3982 s->dc_val[0][s->block_index[i]] = 0;
3984 val = ((cbp >> (5 - i)) & 1);
3985 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
3986 if (v->second_field)
3987 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
3989 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3990 first_block, s->dest[dst_idx] + off,
3991 (i & 4) ? s->uvlinesize : s->linesize,
3992 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3994 block_cbp |= pat << (i << 2);
3995 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4000 if (s->mb_x == s->mb_width - 1)
4001 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4005 /** Decode one B-frame MB (in Main profile)
4007 static void vc1_decode_b_mb(VC1Context *v)
4009 MpegEncContext *s = &v->s;
4010 GetBitContext *gb = &s->gb;
4012 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4013 int cbp = 0; /* cbp decoding stuff */
4014 int mqdiff, mquant; /* MB quantization */
4015 int ttmb = v->ttfrm; /* MB Transform type */
4016 int mb_has_coeffs = 0; /* last_flag */
4017 int index, index1; /* LUT indexes */
4018 int val, sign; /* temp values */
4019 int first_block = 1;
4021 int skipped, direct;
4022 int dmv_x[2], dmv_y[2];
4023 int bmvtype = BMV_TYPE_BACKWARD;
4025 mquant = v->pq; /* lossy initialization */
4029 direct = get_bits1(gb);
4031 direct = v->direct_mb_plane[mb_pos];
4033 skipped = get_bits1(gb);
4035 skipped = v->s.mbskip_table[mb_pos];
4037 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4038 for (i = 0; i < 6; i++) {
4039 v->mb_type[0][s->block_index[i]] = 0;
4040 s->dc_val[0][s->block_index[i]] = 0;
4042 s->current_picture.f.qscale_table[mb_pos] = 0;
4046 GET_MVDATA(dmv_x[0], dmv_y[0]);
4047 dmv_x[1] = dmv_x[0];
4048 dmv_y[1] = dmv_y[0];
4050 if (skipped || !s->mb_intra) {
4051 bmvtype = decode012(gb);
4054 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4057 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4060 bmvtype = BMV_TYPE_INTERPOLATED;
4061 dmv_x[0] = dmv_y[0] = 0;
4065 for (i = 0; i < 6; i++)
4066 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4070 bmvtype = BMV_TYPE_INTERPOLATED;
4071 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4072 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4076 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4079 s->current_picture.f.qscale_table[mb_pos] = mquant;
4081 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4082 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4083 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4084 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4086 if (!mb_has_coeffs && !s->mb_intra) {
4087 /* no coded blocks - effectively skipped */
4088 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4089 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4092 if (s->mb_intra && !mb_has_coeffs) {
4094 s->current_picture.f.qscale_table[mb_pos] = mquant;
4095 s->ac_pred = get_bits1(gb);
4097 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4099 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4100 GET_MVDATA(dmv_x[0], dmv_y[0]);
4101 if (!mb_has_coeffs) {
4102 /* interpolated skipped block */
4103 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4104 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4108 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4110 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4113 s->ac_pred = get_bits1(gb);
4114 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4116 s->current_picture.f.qscale_table[mb_pos] = mquant;
4117 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4118 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4122 for (i = 0; i < 6; i++) {
4123 s->dc_val[0][s->block_index[i]] = 0;
4125 val = ((cbp >> (5 - i)) & 1);
4126 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4127 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4129 /* check if prediction blocks A and C are available */
4130 v->a_avail = v->c_avail = 0;
4131 if (i == 2 || i == 3 || !s->first_slice_line)
4132 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4133 if (i == 1 || i == 3 || s->mb_x)
4134 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4136 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4137 (i & 4) ? v->codingset2 : v->codingset);
4138 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4140 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4142 for (j = 0; j < 64; j++)
4143 s->block[i][j] <<= 1;
4144 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4146 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4147 first_block, s->dest[dst_idx] + off,
4148 (i & 4) ? s->uvlinesize : s->linesize,
4149 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4150 if (!v->ttmbf && ttmb < 8)
4157 /** Decode one B-frame MB (in interlaced field B picture)
4159 static void vc1_decode_b_mb_intfi(VC1Context *v)
4161 MpegEncContext *s = &v->s;
4162 GetBitContext *gb = &s->gb;
4164 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4165 int cbp = 0; /* cbp decoding stuff */
4166 int mqdiff, mquant; /* MB quantization */
4167 int ttmb = v->ttfrm; /* MB Transform type */
4168 int mb_has_coeffs = 0; /* last_flag */
4169 int val; /* temp value */
4170 int first_block = 1;
4173 int dmv_x[2], dmv_y[2], pred_flag[2];
4174 int bmvtype = BMV_TYPE_BACKWARD;
4175 int idx_mbmode, interpmvp;
4177 mquant = v->pq; /* Lossy initialization */
4180 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4181 if (idx_mbmode <= 1) { // intra MB
4182 s->mb_intra = v->is_intra[s->mb_x] = 1;
4183 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4184 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4185 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4187 s->current_picture.f.qscale_table[mb_pos] = mquant;
4188 /* Set DC scale - y and c use the same (not sure if necessary here) */
4189 s->y_dc_scale = s->y_dc_scale_table[mquant];
4190 s->c_dc_scale = s->c_dc_scale_table[mquant];
4191 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4192 mb_has_coeffs = idx_mbmode & 1;
4194 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4196 for (i = 0; i < 6; i++) {
4197 s->dc_val[0][s->block_index[i]] = 0;
4199 val = ((cbp >> (5 - i)) & 1);
4200 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4201 v->a_avail = v->c_avail = 0;
4202 if (i == 2 || i == 3 || !s->first_slice_line)
4203 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4204 if (i == 1 || i == 3 || s->mb_x)
4205 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4207 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4208 (i & 4) ? v->codingset2 : v->codingset);
4209 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4211 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4213 for (j = 0; j < 64; j++)
4214 s->block[i][j] <<= 1;
4215 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4216 off += v->second_field ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4217 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4218 // TODO: yet to perform loop filter
4221 s->mb_intra = v->is_intra[s->mb_x] = 0;
4222 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4223 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4225 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4227 fwd = v->forward_mb_plane[mb_pos];
4228 if (idx_mbmode <= 5) { // 1-MV
4229 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4230 pred_flag[0] = pred_flag[1] = 0;
4232 bmvtype = BMV_TYPE_FORWARD;
4234 bmvtype = decode012(gb);
4237 bmvtype = BMV_TYPE_BACKWARD;
4240 bmvtype = BMV_TYPE_DIRECT;
4243 bmvtype = BMV_TYPE_INTERPOLATED;
4244 interpmvp = get_bits1(gb);
4247 v->bmvtype = bmvtype;
4248 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4249 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4251 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4252 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4254 if (bmvtype == BMV_TYPE_DIRECT) {
4255 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4256 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4258 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4259 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4260 mb_has_coeffs = !(idx_mbmode & 2);
4263 bmvtype = BMV_TYPE_FORWARD;
4264 v->bmvtype = bmvtype;
4265 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4266 for (i = 0; i < 6; i++) {
4268 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4269 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4270 val = ((v->fourmvbp >> (3 - i)) & 1);
4272 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4273 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4274 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4276 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4277 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4279 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4281 mb_has_coeffs = idx_mbmode & 1;
4284 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4288 s->current_picture.f.qscale_table[mb_pos] = mquant;
4289 if (!v->ttmbf && cbp) {
4290 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4293 for (i = 0; i < 6; i++) {
4294 s->dc_val[0][s->block_index[i]] = 0;
4296 val = ((cbp >> (5 - i)) & 1);
4297 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4298 if (v->second_field)
4299 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4301 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4302 first_block, s->dest[dst_idx] + off,
4303 (i & 4) ? s->uvlinesize : s->linesize,
4304 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4305 if (!v->ttmbf && ttmb < 8)
4313 /** Decode blocks of I-frame
4315 static void vc1_decode_i_blocks(VC1Context *v)
4318 MpegEncContext *s = &v->s;
4323 /* select codingmode used for VLC tables selection */
4324 switch (v->y_ac_table_index) {
4326 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4329 v->codingset = CS_HIGH_MOT_INTRA;
4332 v->codingset = CS_MID_RATE_INTRA;
4336 switch (v->c_ac_table_index) {
4338 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4341 v->codingset2 = CS_HIGH_MOT_INTER;
4344 v->codingset2 = CS_MID_RATE_INTER;
4348 /* Set DC scale - y and c use the same */
4349 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4350 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4353 s->mb_x = s->mb_y = 0;
4355 s->first_slice_line = 1;
4356 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4358 ff_init_block_index(s);
4359 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4361 ff_update_block_index(s);
4362 dst[0] = s->dest[0];
4363 dst[1] = dst[0] + 8;
4364 dst[2] = s->dest[0] + s->linesize * 8;
4365 dst[3] = dst[2] + 8;
4366 dst[4] = s->dest[1];
4367 dst[5] = s->dest[2];
4368 s->dsp.clear_blocks(s->block[0]);
4369 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4370 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
4371 s->current_picture.f.qscale_table[mb_pos] = v->pq;
4372 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4373 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4375 // do actual MB decoding and displaying
4376 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4377 v->s.ac_pred = get_bits1(&v->s.gb);
4379 for (k = 0; k < 6; k++) {
4380 val = ((cbp >> (5 - k)) & 1);
4383 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4387 cbp |= val << (5 - k);
4389 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4391 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4393 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4394 if (v->pq >= 9 && v->overlap) {
4396 for (j = 0; j < 64; j++)
4397 s->block[k][j] <<= 1;
4398 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4401 for (j = 0; j < 64; j++)
4402 s->block[k][j] = (s->block[k][j] - 64) << 1;
4403 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4407 if (v->pq >= 9 && v->overlap) {
4409 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4410 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4411 if (!(s->flags & CODEC_FLAG_GRAY)) {
4412 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4413 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4416 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4417 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4418 if (!s->first_slice_line) {
4419 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4420 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4421 if (!(s->flags & CODEC_FLAG_GRAY)) {
4422 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4423 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4426 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4427 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4429 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4431 if (get_bits_count(&s->gb) > v->bits) {
4432 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4433 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4434 get_bits_count(&s->gb), v->bits);
4438 if (!v->s.loop_filter)
4439 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4441 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4443 s->first_slice_line = 0;
4445 if (v->s.loop_filter)
4446 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4448 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4449 * profile, these only differ are when decoding MSS2 rectangles. */
4450 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4453 /** Decode blocks of I-frame for advanced profile
4455 static void vc1_decode_i_blocks_adv(VC1Context *v)
4458 MpegEncContext *s = &v->s;
4464 GetBitContext *gb = &s->gb;
4466 /* select codingmode used for VLC tables selection */
4467 switch (v->y_ac_table_index) {
4469 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4472 v->codingset = CS_HIGH_MOT_INTRA;
4475 v->codingset = CS_MID_RATE_INTRA;
4479 switch (v->c_ac_table_index) {
4481 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4484 v->codingset2 = CS_HIGH_MOT_INTER;
4487 v->codingset2 = CS_MID_RATE_INTER;
4492 s->mb_x = s->mb_y = 0;
4494 s->first_slice_line = 1;
4495 s->mb_y = s->start_mb_y;
4496 if (s->start_mb_y) {
4498 ff_init_block_index(s);
4499 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4500 (1 + s->b8_stride) * sizeof(*s->coded_block));
4502 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4504 ff_init_block_index(s);
4505 for (;s->mb_x < s->mb_width; s->mb_x++) {
4506 DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
4507 ff_update_block_index(s);
4508 s->dsp.clear_blocks(block[0]);
4509 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4510 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4511 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4512 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4514 // do actual MB decoding and displaying
4515 if (v->fieldtx_is_raw)
4516 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4517 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4518 if ( v->acpred_is_raw)
4519 v->s.ac_pred = get_bits1(&v->s.gb);
4521 v->s.ac_pred = v->acpred_plane[mb_pos];
4523 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4524 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4528 s->current_picture.f.qscale_table[mb_pos] = mquant;
4529 /* Set DC scale - y and c use the same */
4530 s->y_dc_scale = s->y_dc_scale_table[mquant];
4531 s->c_dc_scale = s->c_dc_scale_table[mquant];
4533 for (k = 0; k < 6; k++) {
4534 val = ((cbp >> (5 - k)) & 1);
4537 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4541 cbp |= val << (5 - k);
4543 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4544 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4546 vc1_decode_i_block_adv(v, block[k], k, val,
4547 (k < 4) ? v->codingset : v->codingset2, mquant);
4549 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4551 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4554 vc1_smooth_overlap_filter_iblk(v);
4555 vc1_put_signed_blocks_clamped(v);
4556 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4558 if (get_bits_count(&s->gb) > v->bits) {
4559 // TODO: may need modification to handle slice coding
4560 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4561 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4562 get_bits_count(&s->gb), v->bits);
4566 if (!v->s.loop_filter)
4567 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4569 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4570 s->first_slice_line = 0;
4573 /* raw bottom MB row */
4575 ff_init_block_index(s);
4576 for (;s->mb_x < s->mb_width; s->mb_x++) {
4577 ff_update_block_index(s);
4578 vc1_put_signed_blocks_clamped(v);
4579 if (v->s.loop_filter)
4580 vc1_loop_filter_iblk_delayed(v, v->pq);
4582 if (v->s.loop_filter)
4583 ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4584 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4585 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4588 static void vc1_decode_p_blocks(VC1Context *v)
4590 MpegEncContext *s = &v->s;
4591 int apply_loop_filter;
4593 /* select codingmode used for VLC tables selection */
4594 switch (v->c_ac_table_index) {
4596 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4599 v->codingset = CS_HIGH_MOT_INTRA;
4602 v->codingset = CS_MID_RATE_INTRA;
4606 switch (v->c_ac_table_index) {
4608 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4611 v->codingset2 = CS_HIGH_MOT_INTER;
4614 v->codingset2 = CS_MID_RATE_INTER;
4618 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
4619 s->first_slice_line = 1;
4620 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
4621 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4623 ff_init_block_index(s);
4624 for (; s->mb_x < s->mb_width; s->mb_x++) {
4625 ff_update_block_index(s);
4627 if (v->fcm == ILACE_FIELD)
4628 vc1_decode_p_mb_intfi(v);
4629 else if (v->fcm == ILACE_FRAME)
4630 vc1_decode_p_mb_intfr(v);
4631 else vc1_decode_p_mb(v);
4632 if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == PROGRESSIVE)
4633 vc1_apply_p_loop_filter(v);
4634 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4635 // TODO: may need modification to handle slice coding
4636 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4637 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4638 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4642 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
4643 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
4644 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4645 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
4646 if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4647 s->first_slice_line = 0;
4649 if (apply_loop_filter && v->fcm == PROGRESSIVE) {
4651 ff_init_block_index(s);
4652 for (; s->mb_x < s->mb_width; s->mb_x++) {
4653 ff_update_block_index(s);
4654 vc1_apply_p_loop_filter(v);
4657 if (s->end_mb_y >= s->start_mb_y)
4658 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4659 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4660 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4663 static void vc1_decode_b_blocks(VC1Context *v)
4665 MpegEncContext *s = &v->s;
4667 /* select codingmode used for VLC tables selection */
4668 switch (v->c_ac_table_index) {
4670 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4673 v->codingset = CS_HIGH_MOT_INTRA;
4676 v->codingset = CS_MID_RATE_INTRA;
4680 switch (v->c_ac_table_index) {
4682 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4685 v->codingset2 = CS_HIGH_MOT_INTER;
4688 v->codingset2 = CS_MID_RATE_INTER;
4692 s->first_slice_line = 1;
4693 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4695 ff_init_block_index(s);
4696 for (; s->mb_x < s->mb_width; s->mb_x++) {
4697 ff_update_block_index(s);
4699 if (v->fcm == ILACE_FIELD)
4700 vc1_decode_b_mb_intfi(v);
4703 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4704 // TODO: may need modification to handle slice coding
4705 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4706 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4707 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4710 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4712 if (!v->s.loop_filter)
4713 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4715 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4716 s->first_slice_line = 0;
4718 if (v->s.loop_filter)
4719 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4720 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4721 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4724 static void vc1_decode_skip_blocks(VC1Context *v)
4726 MpegEncContext *s = &v->s;
4728 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
4729 s->first_slice_line = 1;
4730 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4732 ff_init_block_index(s);
4733 ff_update_block_index(s);
4734 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4735 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4736 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4737 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4738 s->first_slice_line = 0;
4740 s->pict_type = AV_PICTURE_TYPE_P;
4743 void ff_vc1_decode_blocks(VC1Context *v)
4746 v->s.esc3_level_length = 0;
4748 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
4751 v->left_blk_idx = -1;
4752 v->topleft_blk_idx = 1;
4754 switch (v->s.pict_type) {
4755 case AV_PICTURE_TYPE_I:
4756 if (v->profile == PROFILE_ADVANCED)
4757 vc1_decode_i_blocks_adv(v);
4759 vc1_decode_i_blocks(v);
4761 case AV_PICTURE_TYPE_P:
4762 if (v->p_frame_skipped)
4763 vc1_decode_skip_blocks(v);
4765 vc1_decode_p_blocks(v);
4767 case AV_PICTURE_TYPE_B:
4769 if (v->profile == PROFILE_ADVANCED)
4770 vc1_decode_i_blocks_adv(v);
4772 vc1_decode_i_blocks(v);
4774 vc1_decode_b_blocks(v);
4780 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
4784 * Transform coefficients for both sprites in 16.16 fixed point format,
4785 * in the order they appear in the bitstream:
4787 * rotation 1 (unused)
4789 * rotation 2 (unused)
4796 int effect_type, effect_flag;
4797 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
4798 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
4801 static inline int get_fp_val(GetBitContext* gb)
4803 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
4806 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
4810 switch (get_bits(gb, 2)) {
4813 c[2] = get_fp_val(gb);
4817 c[0] = c[4] = get_fp_val(gb);
4818 c[2] = get_fp_val(gb);
4821 c[0] = get_fp_val(gb);
4822 c[2] = get_fp_val(gb);
4823 c[4] = get_fp_val(gb);
4826 c[0] = get_fp_val(gb);
4827 c[1] = get_fp_val(gb);
4828 c[2] = get_fp_val(gb);
4829 c[3] = get_fp_val(gb);
4830 c[4] = get_fp_val(gb);
4833 c[5] = get_fp_val(gb);
4835 c[6] = get_fp_val(gb);
4840 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
4842 AVCodecContext *avctx = v->s.avctx;
4845 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4846 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
4847 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
4848 av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
4849 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
4850 for (i = 0; i < 7; i++)
4851 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
4852 sd->coefs[sprite][i] / (1<<16),
4853 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
4854 av_log(avctx, AV_LOG_DEBUG, "\n");
4858 if (sd->effect_type = get_bits_long(gb, 30)) {
4859 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
4861 vc1_sprite_parse_transform(gb, sd->effect_params1);
4864 vc1_sprite_parse_transform(gb, sd->effect_params1);
4865 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
4868 for (i = 0; i < sd->effect_pcount1; i++)
4869 sd->effect_params1[i] = get_fp_val(gb);
4871 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
4872 // effect 13 is simple alpha blending and matches the opacity above
4873 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
4874 for (i = 0; i < sd->effect_pcount1; i++)
4875 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4876 sd->effect_params1[i] / (1 << 16),
4877 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
4878 av_log(avctx, AV_LOG_DEBUG, "\n");
4881 sd->effect_pcount2 = get_bits(gb, 16);
4882 if (sd->effect_pcount2 > 10) {
4883 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
4885 } else if (sd->effect_pcount2) {
4887 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
4888 while (++i < sd->effect_pcount2) {
4889 sd->effect_params2[i] = get_fp_val(gb);
4890 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4891 sd->effect_params2[i] / (1 << 16),
4892 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
4894 av_log(avctx, AV_LOG_DEBUG, "\n");
4897 if (sd->effect_flag = get_bits1(gb))
4898 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4900 if (get_bits_count(gb) >= gb->size_in_bits +
4901 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
4902 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4903 if (get_bits_count(gb) < gb->size_in_bits - 8)
4904 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4907 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
4909 int i, plane, row, sprite;
4910 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
4911 uint8_t* src_h[2][2];
4912 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
4914 MpegEncContext *s = &v->s;
4916 for (i = 0; i < 2; i++) {
4917 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
4918 xadv[i] = sd->coefs[i][0];
4919 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
4920 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
4922 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
4923 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
4925 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
4927 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
4928 int width = v->output_width>>!!plane;
4930 for (row = 0; row < v->output_height>>!!plane; row++) {
4931 uint8_t *dst = v->sprite_output_frame.data[plane] +
4932 v->sprite_output_frame.linesize[plane] * row;
4934 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4935 uint8_t *iplane = s->current_picture.f.data[plane];
4936 int iline = s->current_picture.f.linesize[plane];
4937 int ycoord = yoff[sprite] + yadv[sprite] * row;
4938 int yline = ycoord >> 16;
4940 ysub[sprite] = ycoord & 0xFFFF;
4942 iplane = s->last_picture.f.data[plane];
4943 iline = s->last_picture.f.linesize[plane];
4945 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
4946 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4947 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
4949 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
4951 if (sr_cache[sprite][0] != yline) {
4952 if (sr_cache[sprite][1] == yline) {
4953 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
4954 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
4956 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
4957 sr_cache[sprite][0] = yline;
4960 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4961 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
4962 iplane + next_line, xoff[sprite],
4963 xadv[sprite], width);
4964 sr_cache[sprite][1] = yline + 1;
4966 src_h[sprite][0] = v->sr_rows[sprite][0];
4967 src_h[sprite][1] = v->sr_rows[sprite][1];
4971 if (!v->two_sprites) {
4973 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
4975 memcpy(dst, src_h[0][0], width);
4978 if (ysub[0] && ysub[1]) {
4979 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
4980 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
4981 } else if (ysub[0]) {
4982 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
4983 src_h[1][0], alpha, width);
4984 } else if (ysub[1]) {
4985 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
4986 src_h[0][0], (1<<16)-1-alpha, width);
4988 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
4994 for (i = 0; i < 2; i++) {
5004 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5006 MpegEncContext *s = &v->s;
5007 AVCodecContext *avctx = s->avctx;
5010 vc1_parse_sprites(v, gb, &sd);
5012 if (!s->current_picture.f.data[0]) {
5013 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5017 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5018 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5022 if (v->sprite_output_frame.data[0])
5023 avctx->release_buffer(avctx, &v->sprite_output_frame);
5025 v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5026 v->sprite_output_frame.reference = 0;
5027 if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
5028 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5032 vc1_draw_sprites(v, &sd);
5037 static void vc1_sprite_flush(AVCodecContext *avctx)
5039 VC1Context *v = avctx->priv_data;
5040 MpegEncContext *s = &v->s;
5041 AVFrame *f = &s->current_picture.f;
5044 /* Windows Media Image codecs have a convergence interval of two keyframes.
5045 Since we can't enforce it, clear to black the missing sprite. This is
5046 wrong but it looks better than doing nothing. */
5049 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5050 for (i = 0; i < v->sprite_height>>!!plane; i++)
5051 memset(f->data[plane] + i * f->linesize[plane],
5052 plane ? 128 : 0, f->linesize[plane]);
5057 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5059 MpegEncContext *s = &v->s;
5062 /* Allocate mb bitplanes */
5063 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5064 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5065 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5066 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5067 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5068 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5070 v->n_allocated_blks = s->mb_width + 2;
5071 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5072 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5073 v->cbp = v->cbp_base + s->mb_stride;
5074 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5075 v->ttblk = v->ttblk_base + s->mb_stride;
5076 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5077 v->is_intra = v->is_intra_base + s->mb_stride;
5078 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5079 v->luma_mv = v->luma_mv_base + s->mb_stride;
5081 /* allocate block type info in that way so it could be used with s->block_index[] */
5082 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5083 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5084 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5085 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5087 /* allocate memory to store block level MV info */
5088 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5089 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5090 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5091 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5092 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5093 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5094 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
5095 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);
5096 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5097 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5098 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);
5100 /* Init coded blocks info */
5101 if (v->profile == PROFILE_ADVANCED) {
5102 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5104 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5108 ff_intrax8_common_init(&v->x8,s);
5110 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5111 for (i = 0; i < 4; i++)
5112 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5115 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5116 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5123 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5126 for (i = 0; i < 64; i++) {
5127 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5128 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5129 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5130 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5131 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5132 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5138 /** Initialize a VC1/WMV3 decoder
5139 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5140 * @todo TODO: Decypher remaining bits in extra_data
5142 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5144 VC1Context *v = avctx->priv_data;
5145 MpegEncContext *s = &v->s;
5148 /* save the container output size for WMImage */
5149 v->output_width = avctx->width;
5150 v->output_height = avctx->height;
5152 if (!avctx->extradata_size || !avctx->extradata)
5154 if (!(avctx->flags & CODEC_FLAG_GRAY))
5155 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5157 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5158 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5160 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5161 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5163 if (avctx->idct_algo == FF_IDCT_AUTO) {
5164 avctx->idct_algo = FF_IDCT_WMV2;
5167 if (ff_vc1_init_common(v) < 0)
5169 ff_vc1dsp_init(&v->vc1dsp);
5171 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5174 // looks like WMV3 has a sequence header stored in the extradata
5175 // advanced sequence header may be before the first frame
5176 // the last byte of the extradata is a version number, 1 for the
5177 // samples we can decode
5179 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5181 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5184 count = avctx->extradata_size*8 - get_bits_count(&gb);
5186 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5187 count, get_bits(&gb, count));
5188 } else if (count < 0) {
5189 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5191 } else { // VC1/WVC1/WVP2
5192 const uint8_t *start = avctx->extradata;
5193 uint8_t *end = avctx->extradata + avctx->extradata_size;
5194 const uint8_t *next;
5195 int size, buf2_size;
5196 uint8_t *buf2 = NULL;
5197 int seq_initialized = 0, ep_initialized = 0;
5199 if (avctx->extradata_size < 16) {
5200 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5204 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5205 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5207 for (; next < end; start = next) {
5208 next = find_next_marker(start + 4, end);
5209 size = next - start - 4;
5212 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5213 init_get_bits(&gb, buf2, buf2_size * 8);
5214 switch (AV_RB32(start)) {
5215 case VC1_CODE_SEQHDR:
5216 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5220 seq_initialized = 1;
5222 case VC1_CODE_ENTRYPOINT:
5223 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5232 if (!seq_initialized || !ep_initialized) {
5233 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5236 v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
5239 avctx->profile = v->profile;
5240 if (v->profile == PROFILE_ADVANCED)
5241 avctx->level = v->level;
5243 avctx->has_b_frames = !!avctx->max_b_frames;
5245 s->mb_width = (avctx->coded_width + 15) >> 4;
5246 s->mb_height = (avctx->coded_height + 15) >> 4;
5248 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5249 ff_vc1_init_transposed_scantables(v);
5251 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5256 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5257 v->sprite_width = avctx->coded_width;
5258 v->sprite_height = avctx->coded_height;
5260 avctx->coded_width = avctx->width = v->output_width;
5261 avctx->coded_height = avctx->height = v->output_height;
5263 // prevent 16.16 overflows
5264 if (v->sprite_width > 1 << 14 ||
5265 v->sprite_height > 1 << 14 ||
5266 v->output_width > 1 << 14 ||
5267 v->output_height > 1 << 14) return -1;
5272 /** Close a VC1/WMV3 decoder
5273 * @warning Initial try at using MpegEncContext stuff
5275 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5277 VC1Context *v = avctx->priv_data;
5280 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5281 && v->sprite_output_frame.data[0])
5282 avctx->release_buffer(avctx, &v->sprite_output_frame);
5283 for (i = 0; i < 4; i++)
5284 av_freep(&v->sr_rows[i >> 1][i & 1]);
5285 av_freep(&v->hrd_rate);
5286 av_freep(&v->hrd_buffer);
5287 ff_MPV_common_end(&v->s);
5288 av_freep(&v->mv_type_mb_plane);
5289 av_freep(&v->direct_mb_plane);
5290 av_freep(&v->forward_mb_plane);
5291 av_freep(&v->fieldtx_plane);
5292 av_freep(&v->acpred_plane);
5293 av_freep(&v->over_flags_plane);
5294 av_freep(&v->mb_type_base);
5295 av_freep(&v->blk_mv_type_base);
5296 av_freep(&v->mv_f_base);
5297 av_freep(&v->mv_f_last_base);
5298 av_freep(&v->mv_f_next_base);
5299 av_freep(&v->block);
5300 av_freep(&v->cbp_base);
5301 av_freep(&v->ttblk_base);
5302 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5303 av_freep(&v->luma_mv_base);
5304 ff_intrax8_common_end(&v->x8);
5309 /** Decode a VC1/WMV3 frame
5310 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5312 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5313 int *data_size, AVPacket *avpkt)
5315 const uint8_t *buf = avpkt->data;
5316 int buf_size = avpkt->size, n_slices = 0, i;
5317 VC1Context *v = avctx->priv_data;
5318 MpegEncContext *s = &v->s;
5319 AVFrame *pict = data;
5320 uint8_t *buf2 = NULL;
5321 const uint8_t *buf_start = buf;
5322 int mb_height, n_slices1=-1;
5327 } *slices = NULL, *tmp;
5329 if(s->flags & CODEC_FLAG_LOW_DELAY)
5332 /* no supplementary picture */
5333 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5334 /* special case for last picture */
5335 if (s->low_delay == 0 && s->next_picture_ptr) {
5336 *pict = s->next_picture_ptr->f;
5337 s->next_picture_ptr = NULL;
5339 *data_size = sizeof(AVFrame);
5345 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5346 if (v->profile < PROFILE_ADVANCED)
5347 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5349 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5352 //for advanced profile we may need to parse and unescape data
5353 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5355 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5357 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5358 const uint8_t *start, *end, *next;
5362 for (start = buf, end = buf + buf_size; next < end; start = next) {
5363 next = find_next_marker(start + 4, end);
5364 size = next - start - 4;
5365 if (size <= 0) continue;
5366 switch (AV_RB32(start)) {
5367 case VC1_CODE_FRAME:
5368 if (avctx->hwaccel ||
5369 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5371 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5373 case VC1_CODE_FIELD: {
5375 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5379 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5380 if (!slices[n_slices].buf)
5382 buf_size3 = vc1_unescape_buffer(start + 4, size,
5383 slices[n_slices].buf);
5384 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5386 /* assuming that the field marker is at the exact middle,
5387 hope it's correct */
5388 slices[n_slices].mby_start = s->mb_height >> 1;
5389 n_slices1 = n_slices - 1; // index of the last slice of the first field
5393 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5394 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5395 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5396 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5398 case VC1_CODE_SLICE: {
5400 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5404 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5405 if (!slices[n_slices].buf)
5407 buf_size3 = vc1_unescape_buffer(start + 4, size,
5408 slices[n_slices].buf);
5409 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5411 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5417 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5418 const uint8_t *divider;
5421 divider = find_next_marker(buf, buf + buf_size);
5422 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5423 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5425 } else { // found field marker, unescape second field
5426 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5430 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5431 if (!slices[n_slices].buf)
5433 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5434 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5436 slices[n_slices].mby_start = s->mb_height >> 1;
5437 n_slices1 = n_slices - 1;
5440 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5442 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5444 init_get_bits(&s->gb, buf2, buf_size2*8);
5446 init_get_bits(&s->gb, buf, buf_size*8);
5448 if (v->res_sprite) {
5449 v->new_sprite = !get_bits1(&s->gb);
5450 v->two_sprites = get_bits1(&s->gb);
5451 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5452 we're using the sprite compositor. These are intentionally kept separate
5453 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5454 the vc1 one for WVP2 */
5455 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5456 if (v->new_sprite) {
5457 // switch AVCodecContext parameters to those of the sprites
5458 avctx->width = avctx->coded_width = v->sprite_width;
5459 avctx->height = avctx->coded_height = v->sprite_height;
5466 if (s->context_initialized &&
5467 (s->width != avctx->coded_width ||
5468 s->height != avctx->coded_height)) {
5469 ff_vc1_decode_end(avctx);
5472 if (!s->context_initialized) {
5473 if (ff_msmpeg4_decode_init(avctx) < 0 || ff_vc1_decode_init_alloc_tables(v) < 0)
5476 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5478 if (v->profile == PROFILE_ADVANCED) {
5479 s->h_edge_pos = avctx->coded_width;
5480 s->v_edge_pos = avctx->coded_height;
5484 /* We need to set current_picture_ptr before reading the header,
5485 * otherwise we cannot store anything in there. */
5486 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5487 int i = ff_find_unused_picture(s, 0);
5490 s->current_picture_ptr = &s->picture[i];
5493 // do parse frame header
5494 v->pic_header_flag = 0;
5495 if (v->profile < PROFILE_ADVANCED) {
5496 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5500 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5505 if (avctx->debug & FF_DEBUG_PICT_INFO)
5506 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
5508 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5509 && s->pict_type != AV_PICTURE_TYPE_I) {
5510 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5514 // process pulldown flags
5515 s->current_picture_ptr->f.repeat_pict = 0;
5516 // Pulldown flags are only valid when 'broadcast' has been set.
5517 // So ticks_per_frame will be 2
5520 s->current_picture_ptr->f.repeat_pict = 1;
5521 } else if (v->rptfrm) {
5523 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5526 // for skipping the frame
5527 s->current_picture.f.pict_type = s->pict_type;
5528 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5530 /* skip B-frames if we don't have reference frames */
5531 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
5534 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5535 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5536 avctx->skip_frame >= AVDISCARD_ALL) {
5540 if (s->next_p_frame_damaged) {
5541 if (s->pict_type == AV_PICTURE_TYPE_B)
5544 s->next_p_frame_damaged = 0;
5547 if (ff_MPV_frame_start(s, avctx) < 0) {
5551 v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
5552 v->s.current_picture_ptr->f.top_field_first = v->tff;
5554 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5555 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5557 if ((CONFIG_VC1_VDPAU_DECODER)
5558 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5559 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5560 else if (avctx->hwaccel) {
5561 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
5563 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5565 if (avctx->hwaccel->end_frame(avctx) < 0)
5568 ff_er_frame_start(s);
5570 v->bits = buf_size * 8;
5571 v->end_mb_x = s->mb_width;
5572 if (v->field_mode) {
5574 s->current_picture.f.linesize[0] <<= 1;
5575 s->current_picture.f.linesize[1] <<= 1;
5576 s->current_picture.f.linesize[2] <<= 1;
5578 s->uvlinesize <<= 1;
5579 tmp[0] = v->mv_f_last[0];
5580 tmp[1] = v->mv_f_last[1];
5581 v->mv_f_last[0] = v->mv_f_next[0];
5582 v->mv_f_last[1] = v->mv_f_next[1];
5583 v->mv_f_next[0] = v->mv_f[0];
5584 v->mv_f_next[1] = v->mv_f[1];
5585 v->mv_f[0] = tmp[0];
5586 v->mv_f[1] = tmp[1];
5588 mb_height = s->mb_height >> v->field_mode;
5589 for (i = 0; i <= n_slices; i++) {
5590 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5591 if (v->field_mode <= 0) {
5592 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
5593 "picture boundary (%d >= %d)\n", i,
5594 slices[i - 1].mby_start, mb_height);
5597 v->second_field = 1;
5598 v->blocks_off = s->mb_width * s->mb_height << 1;
5599 v->mb_off = s->mb_stride * s->mb_height >> 1;
5601 v->second_field = 0;
5606 v->pic_header_flag = 0;
5607 if (v->field_mode && i == n_slices1 + 2) {
5608 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5609 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
5612 } else if (get_bits1(&s->gb)) {
5613 v->pic_header_flag = 1;
5614 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5615 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
5620 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5621 if (!v->field_mode || v->second_field)
5622 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5624 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5625 if (s->end_mb_y <= s->start_mb_y) {
5626 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
5629 ff_vc1_decode_blocks(v);
5631 s->gb = slices[i].gb;
5633 if (v->field_mode) {
5634 v->second_field = 0;
5635 if (s->pict_type == AV_PICTURE_TYPE_B) {
5636 memcpy(v->mv_f_base, v->mv_f_next_base,
5637 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5639 s->current_picture.f.linesize[0] >>= 1;
5640 s->current_picture.f.linesize[1] >>= 1;
5641 s->current_picture.f.linesize[2] >>= 1;
5643 s->uvlinesize >>= 1;
5645 av_dlog(s->avctx, "Consumed %i/%i bits\n",
5646 get_bits_count(&s->gb), s->gb.size_in_bits);
5647 // if (get_bits_count(&s->gb) > buf_size * 8)
5649 if(s->error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
5655 ff_MPV_frame_end(s);
5657 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5659 avctx->width = avctx->coded_width = v->output_width;
5660 avctx->height = avctx->coded_height = v->output_height;
5661 if (avctx->skip_frame >= AVDISCARD_NONREF)
5663 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5664 if (vc1_decode_sprites(v, &s->gb))
5667 *pict = v->sprite_output_frame;
5668 *data_size = sizeof(AVFrame);
5670 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5671 *pict = s->current_picture_ptr->f;
5672 } else if (s->last_picture_ptr != NULL) {
5673 *pict = s->last_picture_ptr->f;
5675 if (s->last_picture_ptr || s->low_delay) {
5676 *data_size = sizeof(AVFrame);
5677 ff_print_debug_info(s, pict);
5683 for (i = 0; i < n_slices; i++)
5684 av_free(slices[i].buf);
5690 for (i = 0; i < n_slices; i++)
5691 av_free(slices[i].buf);
5697 static const AVProfile profiles[] = {
5698 { FF_PROFILE_VC1_SIMPLE, "Simple" },
5699 { FF_PROFILE_VC1_MAIN, "Main" },
5700 { FF_PROFILE_VC1_COMPLEX, "Complex" },
5701 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5702 { FF_PROFILE_UNKNOWN },
5705 AVCodec ff_vc1_decoder = {
5707 .type = AVMEDIA_TYPE_VIDEO,
5708 .id = AV_CODEC_ID_VC1,
5709 .priv_data_size = sizeof(VC1Context),
5710 .init = vc1_decode_init,
5711 .close = ff_vc1_decode_end,
5712 .decode = vc1_decode_frame,
5713 .flush = ff_mpeg_flush,
5714 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5715 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5716 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5717 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5720 #if CONFIG_WMV3_DECODER
5721 AVCodec ff_wmv3_decoder = {
5723 .type = AVMEDIA_TYPE_VIDEO,
5724 .id = AV_CODEC_ID_WMV3,
5725 .priv_data_size = sizeof(VC1Context),
5726 .init = vc1_decode_init,
5727 .close = ff_vc1_decode_end,
5728 .decode = vc1_decode_frame,
5729 .flush = ff_mpeg_flush,
5730 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5731 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5732 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5733 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5737 #if CONFIG_WMV3_VDPAU_DECODER
5738 AVCodec ff_wmv3_vdpau_decoder = {
5739 .name = "wmv3_vdpau",
5740 .type = AVMEDIA_TYPE_VIDEO,
5741 .id = AV_CODEC_ID_WMV3,
5742 .priv_data_size = sizeof(VC1Context),
5743 .init = vc1_decode_init,
5744 .close = ff_vc1_decode_end,
5745 .decode = vc1_decode_frame,
5746 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5747 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5748 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
5749 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5753 #if CONFIG_VC1_VDPAU_DECODER
5754 AVCodec ff_vc1_vdpau_decoder = {
5755 .name = "vc1_vdpau",
5756 .type = AVMEDIA_TYPE_VIDEO,
5757 .id = AV_CODEC_ID_VC1,
5758 .priv_data_size = sizeof(VC1Context),
5759 .init = vc1_decode_init,
5760 .close = ff_vc1_decode_end,
5761 .decode = vc1_decode_frame,
5762 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5763 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5764 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
5765 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5769 #if CONFIG_WMV3IMAGE_DECODER
5770 AVCodec ff_wmv3image_decoder = {
5771 .name = "wmv3image",
5772 .type = AVMEDIA_TYPE_VIDEO,
5773 .id = AV_CODEC_ID_WMV3IMAGE,
5774 .priv_data_size = sizeof(VC1Context),
5775 .init = vc1_decode_init,
5776 .close = ff_vc1_decode_end,
5777 .decode = vc1_decode_frame,
5778 .capabilities = CODEC_CAP_DR1,
5779 .flush = vc1_sprite_flush,
5780 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5781 .pix_fmts = ff_pixfmt_list_420
5785 #if CONFIG_VC1IMAGE_DECODER
5786 AVCodec ff_vc1image_decoder = {
5788 .type = AVMEDIA_TYPE_VIDEO,
5789 .id = AV_CODEC_ID_VC1IMAGE,
5790 .priv_data_size = sizeof(VC1Context),
5791 .init = vc1_decode_init,
5792 .close = ff_vc1_decode_end,
5793 .decode = vc1_decode_frame,
5794 .capabilities = CODEC_CAP_DR1,
5795 .flush = vc1_sprite_flush,
5796 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5797 .pix_fmts = ff_pixfmt_list_420