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;
608 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
609 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
610 for (k = 0; k < 4; k++)
611 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
614 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
616 int width = s->avctx->coded_width;
617 int height = s->avctx->coded_height >> 1;
618 qx = (s->mb_x * 16) + (mx >> 2);
619 qy = (s->mb_y * 8) + (my >> 3);
624 mx -= 4 * (qx - width);
627 else if (qy > height + 1)
628 my -= 8 * (qy - height - 1);
631 if ((v->fcm == ILACE_FRAME) && fieldmv)
632 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
634 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
635 if (v->field_mode && v->second_field)
636 off += s->current_picture_ptr->f.linesize[0];
638 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
640 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
642 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
644 if (v->profile != PROFILE_ADVANCED) {
645 src_x = av_clip(src_x, -16, s->mb_width * 16);
646 src_y = av_clip(src_y, -16, s->mb_height * 16);
648 src_x = av_clip(src_x, -17, s->avctx->coded_width);
649 if (v->fcm == ILACE_FRAME) {
651 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
653 src_y = av_clip(src_y, -18, s->avctx->coded_height);
655 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
659 srcY += src_y * s->linesize + src_x;
660 if (v->field_mode && v->ref_field_type[dir])
661 srcY += s->current_picture_ptr->f.linesize[0];
663 if (fieldmv && !(src_y & 1))
665 if (fieldmv && (src_y & 1) && src_y < 4)
667 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
668 || s->h_edge_pos < 13 || v_edge_pos < 23
669 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
670 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
671 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
672 /* check emulate edge stride and offset */
673 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
674 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
675 src_x - s->mspel, src_y - (s->mspel << fieldmv),
676 s->h_edge_pos, v_edge_pos);
677 srcY = s->edge_emu_buffer;
678 /* if we deal with range reduction we need to scale source blocks */
679 if (v->rangeredfrm) {
684 for (j = 0; j < 9 + s->mspel * 2; j++) {
685 for (i = 0; i < 9 + s->mspel * 2; i++)
686 src[i] = ((src[i] - 128) >> 1) + 128;
687 src += s->linesize << fieldmv;
690 /* if we deal with intensity compensation we need to scale source blocks */
691 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
696 for (j = 0; j < 9 + s->mspel * 2; j++) {
697 for (i = 0; i < 9 + s->mspel * 2; i++)
698 src[i] = v->luty[src[i]];
699 src += s->linesize << fieldmv;
702 srcY += s->mspel * (1 + (s->linesize << fieldmv));
706 dxy = ((my & 3) << 2) | (mx & 3);
707 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
708 } else { // hpel mc - always used for luma
709 dxy = (my & 2) | ((mx & 2) >> 1);
711 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
713 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
717 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
720 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
722 idx = ((a[3] != flag) << 3)
723 | ((a[2] != flag) << 2)
724 | ((a[1] != flag) << 1)
727 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
728 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
730 } else if (count[idx] == 1) {
733 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
734 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
737 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
738 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
741 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
742 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
745 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
746 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
749 } else if (count[idx] == 2) {
751 for (i = 0; i < 3; i++)
756 for (i = t1 + 1; i < 4; i++)
761 *tx = (mvx[t1] + mvx[t2]) / 2;
762 *ty = (mvy[t1] + mvy[t2]) / 2;
770 /** Do motion compensation for 4-MV macroblock - both chroma blocks
772 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
774 MpegEncContext *s = &v->s;
775 DSPContext *dsp = &v->s.dsp;
776 uint8_t *srcU, *srcV;
777 int uvmx, uvmy, uvsrc_x, uvsrc_y;
778 int k, tx = 0, ty = 0;
779 int mvx[4], mvy[4], intra[4], mv_f[4];
781 int chroma_ref_type = v->cur_field_type, off = 0;
782 int v_edge_pos = s->v_edge_pos >> v->field_mode;
784 if (!v->field_mode && !v->s.last_picture.f.data[0])
786 if (s->flags & CODEC_FLAG_GRAY)
789 for (k = 0; k < 4; k++) {
790 mvx[k] = s->mv[dir][k][0];
791 mvy[k] = s->mv[dir][k][1];
792 intra[k] = v->mb_type[0][s->block_index[k]];
794 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
797 /* calculate chroma MV vector from four luma MVs */
798 if (!v->field_mode || (v->field_mode && !v->numref)) {
799 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
800 chroma_ref_type = v->reffield;
802 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
803 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
804 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
805 return; //no need to do MC for intra blocks
809 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
811 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
813 chroma_ref_type = !v->cur_field_type;
815 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
817 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
818 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
819 uvmx = (tx + ((tx & 3) == 3)) >> 1;
820 uvmy = (ty + ((ty & 3) == 3)) >> 1;
822 v->luma_mv[s->mb_x][0] = uvmx;
823 v->luma_mv[s->mb_x][1] = uvmy;
826 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
827 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
829 // Field conversion bias
830 if (v->cur_field_type != chroma_ref_type)
831 uvmy += 2 - 4 * chroma_ref_type;
833 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
834 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
836 if (v->profile != PROFILE_ADVANCED) {
837 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
838 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
840 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
841 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
846 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
847 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
848 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
850 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
851 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
854 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
855 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
858 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
859 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
863 if (chroma_ref_type) {
864 srcU += s->current_picture_ptr->f.linesize[1];
865 srcV += s->current_picture_ptr->f.linesize[2];
867 off = v->second_field ? s->current_picture_ptr->f.linesize[1] : 0;
870 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
871 || s->h_edge_pos < 18 || v_edge_pos < 18
872 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
873 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
874 s->dsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
875 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
876 s->h_edge_pos >> 1, v_edge_pos >> 1);
877 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
878 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
879 s->h_edge_pos >> 1, v_edge_pos >> 1);
880 srcU = s->edge_emu_buffer;
881 srcV = s->edge_emu_buffer + 16;
883 /* if we deal with range reduction we need to scale source blocks */
884 if (v->rangeredfrm) {
890 for (j = 0; j < 9; j++) {
891 for (i = 0; i < 9; i++) {
892 src[i] = ((src[i] - 128) >> 1) + 128;
893 src2[i] = ((src2[i] - 128) >> 1) + 128;
895 src += s->uvlinesize;
896 src2 += s->uvlinesize;
899 /* if we deal with intensity compensation we need to scale source blocks */
900 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
906 for (j = 0; j < 9; j++) {
907 for (i = 0; i < 9; i++) {
908 src[i] = v->lutuv[src[i]];
909 src2[i] = v->lutuv[src2[i]];
911 src += s->uvlinesize;
912 src2 += s->uvlinesize;
917 /* Chroma MC always uses qpel bilinear */
918 uvmx = (uvmx & 3) << 1;
919 uvmy = (uvmy & 3) << 1;
921 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
922 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
924 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
925 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
929 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
931 static void vc1_mc_4mv_chroma4(VC1Context *v)
933 MpegEncContext *s = &v->s;
934 DSPContext *dsp = &v->s.dsp;
935 uint8_t *srcU, *srcV;
936 int uvsrc_x, uvsrc_y;
937 int uvmx_field[4], uvmy_field[4];
939 int fieldmv = v->blk_mv_type[s->block_index[0]];
940 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
941 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
942 int v_edge_pos = s->v_edge_pos >> 1;
944 if (!v->s.last_picture.f.data[0])
946 if (s->flags & CODEC_FLAG_GRAY)
949 for (i = 0; i < 4; i++) {
951 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
954 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
956 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
959 for (i = 0; i < 4; i++) {
960 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
961 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
962 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
963 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
964 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
965 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
966 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
967 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
968 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
969 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
971 if (fieldmv && !(uvsrc_y & 1))
973 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
975 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
976 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
977 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
978 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
979 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
980 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
981 s->h_edge_pos >> 1, v_edge_pos);
982 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
983 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
984 s->h_edge_pos >> 1, v_edge_pos);
985 srcU = s->edge_emu_buffer;
986 srcV = s->edge_emu_buffer + 16;
988 /* if we deal with intensity compensation we need to scale source blocks */
989 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
995 for (j = 0; j < 5; j++) {
996 for (i = 0; i < 5; i++) {
997 src[i] = v->lutuv[src[i]];
998 src2[i] = v->lutuv[src2[i]];
1000 src += s->uvlinesize << 1;
1001 src2 += s->uvlinesize << 1;
1006 dsp->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1007 dsp->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1009 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]);
1010 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]);
1015 /***********************************************************************/
1017 * @name VC-1 Block-level functions
1018 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1024 * @brief Get macroblock-level quantizer scale
1026 #define GET_MQUANT() \
1027 if (v->dquantfrm) { \
1029 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1030 if (v->dqbilevel) { \
1031 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1033 mqdiff = get_bits(gb, 3); \
1035 mquant = v->pq + mqdiff; \
1037 mquant = get_bits(gb, 5); \
1040 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1041 edges = 1 << v->dqsbedge; \
1042 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1043 edges = (3 << v->dqsbedge) % 15; \
1044 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1046 if ((edges&1) && !s->mb_x) \
1047 mquant = v->altpq; \
1048 if ((edges&2) && s->first_slice_line) \
1049 mquant = v->altpq; \
1050 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1051 mquant = v->altpq; \
1052 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1053 mquant = v->altpq; \
1054 if (!mquant || mquant > 31) { \
1055 av_log(v->s.avctx, AV_LOG_ERROR, \
1056 "Overriding invalid mquant %d\n", mquant); \
1062 * @def GET_MVDATA(_dmv_x, _dmv_y)
1063 * @brief Get MV differentials
1064 * @see MVDATA decoding from 8.3.5.2, p(1)20
1065 * @param _dmv_x Horizontal differential for decoded MV
1066 * @param _dmv_y Vertical differential for decoded MV
1068 #define GET_MVDATA(_dmv_x, _dmv_y) \
1069 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1070 VC1_MV_DIFF_VLC_BITS, 2); \
1072 mb_has_coeffs = 1; \
1075 mb_has_coeffs = 0; \
1078 _dmv_x = _dmv_y = 0; \
1079 } else if (index == 35) { \
1080 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1081 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1082 } else if (index == 36) { \
1087 index1 = index % 6; \
1088 if (!s->quarter_sample && index1 == 5) val = 1; \
1090 if (size_table[index1] - val > 0) \
1091 val = get_bits(gb, size_table[index1] - val); \
1093 sign = 0 - (val&1); \
1094 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1096 index1 = index / 6; \
1097 if (!s->quarter_sample && index1 == 5) val = 1; \
1099 if (size_table[index1] - val > 0) \
1100 val = get_bits(gb, size_table[index1] - val); \
1102 sign = 0 - (val & 1); \
1103 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1106 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1107 int *dmv_y, int *pred_flag)
1110 int extend_x = 0, extend_y = 0;
1111 GetBitContext *gb = &v->s.gb;
1114 const int* offs_tab;
1117 bits = VC1_2REF_MVDATA_VLC_BITS;
1120 bits = VC1_1REF_MVDATA_VLC_BITS;
1123 switch (v->dmvrange) {
1131 extend_x = extend_y = 1;
1134 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1136 *dmv_x = get_bits(gb, v->k_x);
1137 *dmv_y = get_bits(gb, v->k_y);
1139 *pred_flag = *dmv_y & 1;
1140 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1144 av_assert0(index < esc);
1146 offs_tab = offset_table2;
1148 offs_tab = offset_table1;
1149 index1 = (index + 1) % 9;
1151 val = get_bits(gb, index1 + extend_x);
1152 sign = 0 -(val & 1);
1153 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1157 offs_tab = offset_table2;
1159 offs_tab = offset_table1;
1160 index1 = (index + 1) / 9;
1161 if (index1 > v->numref) {
1162 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1163 sign = 0 - (val & 1);
1164 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1168 *pred_flag = index1 & 1;
1172 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1174 int scaledvalue, refdist;
1175 int scalesame1, scalesame2;
1176 int scalezone1_x, zone1offset_x;
1177 int table_index = dir ^ v->second_field;
1179 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1180 refdist = v->refdist;
1182 refdist = dir ? v->brfd : v->frfd;
1185 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1186 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1187 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1188 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1193 if (FFABS(n) < scalezone1_x)
1194 scaledvalue = (n * scalesame1) >> 8;
1197 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1199 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1202 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1205 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1207 int scaledvalue, refdist;
1208 int scalesame1, scalesame2;
1209 int scalezone1_y, zone1offset_y;
1210 int table_index = dir ^ v->second_field;
1212 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1213 refdist = v->refdist;
1215 refdist = dir ? v->brfd : v->frfd;
1218 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1219 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1220 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1221 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1226 if (FFABS(n) < scalezone1_y)
1227 scaledvalue = (n * scalesame1) >> 8;
1230 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1232 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1236 if (v->cur_field_type && !v->ref_field_type[dir])
1237 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1239 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1242 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1244 int scalezone1_x, zone1offset_x;
1245 int scaleopp1, scaleopp2, brfd;
1248 brfd = FFMIN(v->brfd, 3);
1249 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1250 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1251 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1252 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1257 if (FFABS(n) < scalezone1_x)
1258 scaledvalue = (n * scaleopp1) >> 8;
1261 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1263 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1266 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1269 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1271 int scalezone1_y, zone1offset_y;
1272 int scaleopp1, scaleopp2, brfd;
1275 brfd = FFMIN(v->brfd, 3);
1276 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1277 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1278 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1279 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1284 if (FFABS(n) < scalezone1_y)
1285 scaledvalue = (n * scaleopp1) >> 8;
1288 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1290 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1293 if (v->cur_field_type && !v->ref_field_type[dir]) {
1294 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1296 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1300 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1303 int brfd, scalesame;
1304 int hpel = 1 - v->s.quarter_sample;
1307 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1309 n = scaleforsame_y(v, i, n, dir) << hpel;
1311 n = scaleforsame_x(v, n, dir) << hpel;
1314 brfd = FFMIN(v->brfd, 3);
1315 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1317 n = (n * scalesame >> 8) << hpel;
1321 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1324 int refdist, scaleopp;
1325 int hpel = 1 - v->s.quarter_sample;
1328 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1330 n = scaleforopp_y(v, n, dir) << hpel;
1332 n = scaleforopp_x(v, n) << hpel;
1335 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1336 refdist = FFMIN(v->refdist, 3);
1338 refdist = dir ? v->brfd : v->frfd;
1339 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1341 n = (n * scaleopp >> 8) << hpel;
1345 /** Predict and set motion vector
1347 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1348 int mv1, int r_x, int r_y, uint8_t* is_intra,
1349 int pred_flag, int dir)
1351 MpegEncContext *s = &v->s;
1352 int xy, wrap, off = 0;
1356 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1357 int opposite, a_f, b_f, c_f;
1358 int16_t field_predA[2];
1359 int16_t field_predB[2];
1360 int16_t field_predC[2];
1361 int a_valid, b_valid, c_valid;
1362 int hybridmv_thresh, y_bias = 0;
1364 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1365 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1369 /* scale MV difference to be quad-pel */
1370 dmv_x <<= 1 - s->quarter_sample;
1371 dmv_y <<= 1 - s->quarter_sample;
1373 wrap = s->b8_stride;
1374 xy = s->block_index[n];
1377 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
1378 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
1379 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
1380 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
1381 if (mv1) { /* duplicate motion data for 1-MV block */
1382 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1383 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1384 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1385 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1386 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1387 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1388 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1389 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1390 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1391 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1392 s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1393 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1394 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1399 C = s->current_picture.f.motion_val[dir][xy - 1 + v->blocks_off];
1400 A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
1402 if (v->field_mode && mixedmv_pic)
1403 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1405 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1407 //in 4-MV mode different blocks have different B predictor position
1410 off = (s->mb_x > 0) ? -1 : 1;
1413 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1422 B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
1424 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1425 b_valid = a_valid && (s->mb_width > 1);
1426 c_valid = s->mb_x || (n == 1 || n == 3);
1427 if (v->field_mode) {
1428 a_valid = a_valid && !is_intra[xy - wrap];
1429 b_valid = b_valid && !is_intra[xy - wrap + off];
1430 c_valid = c_valid && !is_intra[xy - 1];
1434 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1435 num_oppfield += a_f;
1436 num_samefield += 1 - a_f;
1437 field_predA[0] = A[0];
1438 field_predA[1] = A[1];
1440 field_predA[0] = field_predA[1] = 0;
1444 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1445 num_oppfield += b_f;
1446 num_samefield += 1 - b_f;
1447 field_predB[0] = B[0];
1448 field_predB[1] = B[1];
1450 field_predB[0] = field_predB[1] = 0;
1454 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1455 num_oppfield += c_f;
1456 num_samefield += 1 - c_f;
1457 field_predC[0] = C[0];
1458 field_predC[1] = C[1];
1460 field_predC[0] = field_predC[1] = 0;
1464 if (v->field_mode) {
1466 // REFFIELD determines if the last field or the second-last field is
1467 // to be used as reference
1468 opposite = 1 - v->reffield;
1470 if (num_samefield <= num_oppfield)
1471 opposite = 1 - pred_flag;
1473 opposite = pred_flag;
1478 if (a_valid && !a_f) {
1479 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1480 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1482 if (b_valid && !b_f) {
1483 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1484 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1486 if (c_valid && !c_f) {
1487 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1488 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1490 v->mv_f[dir][xy + v->blocks_off] = 1;
1491 v->ref_field_type[dir] = !v->cur_field_type;
1493 if (a_valid && a_f) {
1494 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1495 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1497 if (b_valid && b_f) {
1498 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1499 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1501 if (c_valid && c_f) {
1502 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1503 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1505 v->mv_f[dir][xy + v->blocks_off] = 0;
1506 v->ref_field_type[dir] = v->cur_field_type;
1510 px = field_predA[0];
1511 py = field_predA[1];
1512 } else if (c_valid) {
1513 px = field_predC[0];
1514 py = field_predC[1];
1515 } else if (b_valid) {
1516 px = field_predB[0];
1517 py = field_predB[1];
1523 if (num_samefield + num_oppfield > 1) {
1524 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1525 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1528 /* Pullback MV as specified in 8.3.5.3.4 */
1529 if (!v->field_mode) {
1531 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1532 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1533 X = (s->mb_width << 6) - 4;
1534 Y = (s->mb_height << 6) - 4;
1536 if (qx + px < -60) px = -60 - qx;
1537 if (qy + py < -60) py = -60 - qy;
1539 if (qx + px < -28) px = -28 - qx;
1540 if (qy + py < -28) py = -28 - qy;
1542 if (qx + px > X) px = X - qx;
1543 if (qy + py > Y) py = Y - qy;
1546 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1547 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1548 hybridmv_thresh = 32;
1549 if (a_valid && c_valid) {
1550 if (is_intra[xy - wrap])
1551 sum = FFABS(px) + FFABS(py);
1553 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1554 if (sum > hybridmv_thresh) {
1555 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1556 px = field_predA[0];
1557 py = field_predA[1];
1559 px = field_predC[0];
1560 py = field_predC[1];
1563 if (is_intra[xy - 1])
1564 sum = FFABS(px) + FFABS(py);
1566 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1567 if (sum > hybridmv_thresh) {
1568 if (get_bits1(&s->gb)) {
1569 px = field_predA[0];
1570 py = field_predA[1];
1572 px = field_predC[0];
1573 py = field_predC[1];
1580 if (v->field_mode && v->numref)
1582 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1584 /* store MV using signed modulus of MV range defined in 4.11 */
1585 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;
1586 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;
1587 if (mv1) { /* duplicate motion data for 1-MV block */
1588 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];
1589 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];
1590 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];
1591 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];
1592 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];
1593 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];
1594 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1595 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];
1599 /** Predict and set motion vector for interlaced frame picture MBs
1601 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1602 int mvn, int r_x, int r_y, uint8_t* is_intra)
1604 MpegEncContext *s = &v->s;
1605 int xy, wrap, off = 0;
1606 int A[2], B[2], C[2];
1608 int a_valid = 0, b_valid = 0, c_valid = 0;
1609 int field_a, field_b, field_c; // 0: same, 1: opposit
1610 int total_valid, num_samefield, num_oppfield;
1611 int pos_c, pos_b, n_adj;
1613 wrap = s->b8_stride;
1614 xy = s->block_index[n];
1617 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
1618 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
1619 s->current_picture.f.motion_val[1][xy][0] = 0;
1620 s->current_picture.f.motion_val[1][xy][1] = 0;
1621 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1622 s->current_picture.f.motion_val[0][xy + 1][0] = 0;
1623 s->current_picture.f.motion_val[0][xy + 1][1] = 0;
1624 s->current_picture.f.motion_val[0][xy + wrap][0] = 0;
1625 s->current_picture.f.motion_val[0][xy + wrap][1] = 0;
1626 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
1627 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
1628 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1629 s->current_picture.f.motion_val[1][xy + 1][0] = 0;
1630 s->current_picture.f.motion_val[1][xy + 1][1] = 0;
1631 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1632 s->current_picture.f.motion_val[1][xy + wrap][1] = 0;
1633 s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
1634 s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
1639 off = ((n == 0) || (n == 1)) ? 1 : -1;
1641 if (s->mb_x || (n == 1) || (n == 3)) {
1642 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1643 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1644 A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
1645 A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
1647 } else { // current block has frame mv and cand. has field MV (so average)
1648 A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
1649 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1650 A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
1651 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1654 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1660 /* Predict B and C */
1661 B[0] = B[1] = C[0] = C[1] = 0;
1662 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1663 if (!s->first_slice_line) {
1664 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1667 pos_b = s->block_index[n_adj] - 2 * wrap;
1668 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1669 n_adj = (n & 2) | (n & 1);
1671 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1672 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1673 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1674 B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1675 B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1678 if (s->mb_width > 1) {
1679 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1682 pos_c = s->block_index[2] - 2 * wrap + 2;
1683 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1686 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1687 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1688 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1689 C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1690 C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1692 if (s->mb_x == s->mb_width - 1) {
1693 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1696 pos_c = s->block_index[3] - 2 * wrap - 2;
1697 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1700 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1701 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1702 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1703 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1704 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1713 pos_b = s->block_index[1];
1715 B[0] = s->current_picture.f.motion_val[0][pos_b][0];
1716 B[1] = s->current_picture.f.motion_val[0][pos_b][1];
1717 pos_c = s->block_index[0];
1719 C[0] = s->current_picture.f.motion_val[0][pos_c][0];
1720 C[1] = s->current_picture.f.motion_val[0][pos_c][1];
1723 total_valid = a_valid + b_valid + c_valid;
1724 // check if predictor A is out of bounds
1725 if (!s->mb_x && !(n == 1 || n == 3)) {
1728 // check if predictor B is out of bounds
1729 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1730 B[0] = B[1] = C[0] = C[1] = 0;
1732 if (!v->blk_mv_type[xy]) {
1733 if (s->mb_width == 1) {
1737 if (total_valid >= 2) {
1738 px = mid_pred(A[0], B[0], C[0]);
1739 py = mid_pred(A[1], B[1], C[1]);
1740 } else if (total_valid) {
1741 if (a_valid) { px = A[0]; py = A[1]; }
1742 if (b_valid) { px = B[0]; py = B[1]; }
1743 if (c_valid) { px = C[0]; py = C[1]; }
1749 field_a = (A[1] & 4) ? 1 : 0;
1753 field_b = (B[1] & 4) ? 1 : 0;
1757 field_c = (C[1] & 4) ? 1 : 0;
1761 num_oppfield = field_a + field_b + field_c;
1762 num_samefield = total_valid - num_oppfield;
1763 if (total_valid == 3) {
1764 if ((num_samefield == 3) || (num_oppfield == 3)) {
1765 px = mid_pred(A[0], B[0], C[0]);
1766 py = mid_pred(A[1], B[1], C[1]);
1767 } else if (num_samefield >= num_oppfield) {
1768 /* take one MV from same field set depending on priority
1769 the check for B may not be necessary */
1770 px = !field_a ? A[0] : B[0];
1771 py = !field_a ? A[1] : B[1];
1773 px = field_a ? A[0] : B[0];
1774 py = field_a ? A[1] : B[1];
1776 } else if (total_valid == 2) {
1777 if (num_samefield >= num_oppfield) {
1778 if (!field_a && a_valid) {
1781 } else if (!field_b && b_valid) {
1784 } else if (c_valid) {
1789 if (field_a && a_valid) {
1792 } else if (field_b && b_valid) {
1795 } else if (c_valid) {
1800 } else if (total_valid == 1) {
1801 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1802 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1807 /* store MV using signed modulus of MV range defined in 4.11 */
1808 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;
1809 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;
1810 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1811 s->current_picture.f.motion_val[0][xy + 1 ][0] = s->current_picture.f.motion_val[0][xy][0];
1812 s->current_picture.f.motion_val[0][xy + 1 ][1] = s->current_picture.f.motion_val[0][xy][1];
1813 s->current_picture.f.motion_val[0][xy + wrap ][0] = s->current_picture.f.motion_val[0][xy][0];
1814 s->current_picture.f.motion_val[0][xy + wrap ][1] = s->current_picture.f.motion_val[0][xy][1];
1815 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1816 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1817 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1818 s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1819 s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1820 s->mv[0][n + 1][0] = s->mv[0][n][0];
1821 s->mv[0][n + 1][1] = s->mv[0][n][1];
1825 /** Motion compensation for direct or interpolated blocks in B-frames
1827 static void vc1_interp_mc(VC1Context *v)
1829 MpegEncContext *s = &v->s;
1830 DSPContext *dsp = &v->s.dsp;
1831 uint8_t *srcY, *srcU, *srcV;
1832 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1834 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1836 if (!v->field_mode && !v->s.next_picture.f.data[0])
1839 mx = s->mv[1][0][0];
1840 my = s->mv[1][0][1];
1841 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1842 uvmy = (my + ((my & 3) == 3)) >> 1;
1843 if (v->field_mode) {
1844 if (v->cur_field_type != v->ref_field_type[1])
1845 my = my - 2 + 4 * v->cur_field_type;
1846 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1849 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1850 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1852 srcY = s->next_picture.f.data[0];
1853 srcU = s->next_picture.f.data[1];
1854 srcV = s->next_picture.f.data[2];
1856 src_x = s->mb_x * 16 + (mx >> 2);
1857 src_y = s->mb_y * 16 + (my >> 2);
1858 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1859 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1861 if (v->profile != PROFILE_ADVANCED) {
1862 src_x = av_clip( src_x, -16, s->mb_width * 16);
1863 src_y = av_clip( src_y, -16, s->mb_height * 16);
1864 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1865 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1867 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1868 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1869 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1870 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1873 srcY += src_y * s->linesize + src_x;
1874 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1875 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1877 if (v->field_mode && v->ref_field_type[1]) {
1878 srcY += s->current_picture_ptr->f.linesize[0];
1879 srcU += s->current_picture_ptr->f.linesize[1];
1880 srcV += s->current_picture_ptr->f.linesize[2];
1883 /* for grayscale we should not try to read from unknown area */
1884 if (s->flags & CODEC_FLAG_GRAY) {
1885 srcU = s->edge_emu_buffer + 18 * s->linesize;
1886 srcV = s->edge_emu_buffer + 18 * s->linesize;
1889 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1890 || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1891 || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1892 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1894 srcY -= s->mspel * (1 + s->linesize);
1895 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1896 17 + s->mspel * 2, 17 + s->mspel * 2,
1897 src_x - s->mspel, src_y - s->mspel,
1898 s->h_edge_pos, v_edge_pos);
1899 srcY = s->edge_emu_buffer;
1900 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1901 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1902 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1903 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1906 /* if we deal with range reduction we need to scale source blocks */
1907 if (v->rangeredfrm) {
1909 uint8_t *src, *src2;
1912 for (j = 0; j < 17 + s->mspel * 2; j++) {
1913 for (i = 0; i < 17 + s->mspel * 2; i++)
1914 src[i] = ((src[i] - 128) >> 1) + 128;
1919 for (j = 0; j < 9; j++) {
1920 for (i = 0; i < 9; i++) {
1921 src[i] = ((src[i] - 128) >> 1) + 128;
1922 src2[i] = ((src2[i] - 128) >> 1) + 128;
1924 src += s->uvlinesize;
1925 src2 += s->uvlinesize;
1928 srcY += s->mspel * (1 + s->linesize);
1931 if (v->field_mode && v->second_field) {
1932 off = s->current_picture_ptr->f.linesize[0];
1933 off_uv = s->current_picture_ptr->f.linesize[1];
1940 dxy = ((my & 3) << 2) | (mx & 3);
1941 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
1942 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1943 srcY += s->linesize * 8;
1944 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
1945 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1947 dxy = (my & 2) | ((mx & 2) >> 1);
1950 dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1952 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1955 if (s->flags & CODEC_FLAG_GRAY) return;
1956 /* Chroma MC always uses qpel blilinear */
1957 uvmx = (uvmx & 3) << 1;
1958 uvmy = (uvmy & 3) << 1;
1960 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1961 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1963 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1964 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1968 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1972 #if B_FRACTION_DEN==256
1976 return 2 * ((value * n + 255) >> 9);
1977 return (value * n + 128) >> 8;
1980 n -= B_FRACTION_DEN;
1982 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1983 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1987 /** Reconstruct motion vector for B-frame and do motion compensation
1989 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
1990 int direct, int mode)
1993 v->mv_mode2 = v->mv_mode;
1994 v->mv_mode = MV_PMODE_INTENSITY_COMP;
2000 v->mv_mode = v->mv_mode2;
2003 if (mode == BMV_TYPE_INTERPOLATED) {
2007 v->mv_mode = v->mv_mode2;
2011 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2012 v->mv_mode = v->mv_mode2;
2013 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2015 v->mv_mode = v->mv_mode2;
2018 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2019 int direct, int mvtype)
2021 MpegEncContext *s = &v->s;
2022 int xy, wrap, off = 0;
2027 const uint8_t *is_intra = v->mb_type[0];
2031 /* scale MV difference to be quad-pel */
2032 dmv_x[0] <<= 1 - s->quarter_sample;
2033 dmv_y[0] <<= 1 - s->quarter_sample;
2034 dmv_x[1] <<= 1 - s->quarter_sample;
2035 dmv_y[1] <<= 1 - s->quarter_sample;
2037 wrap = s->b8_stride;
2038 xy = s->block_index[0];
2041 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
2042 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
2043 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
2044 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
2047 if (!v->field_mode) {
2048 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2049 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2050 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2051 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2053 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2054 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));
2055 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));
2056 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));
2057 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));
2060 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2061 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2062 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2063 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2067 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2068 C = s->current_picture.f.motion_val[0][xy - 2];
2069 A = s->current_picture.f.motion_val[0][xy - wrap * 2];
2070 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2071 B = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
2073 if (!s->mb_x) C[0] = C[1] = 0;
2074 if (!s->first_slice_line) { // predictor A is not out of bounds
2075 if (s->mb_width == 1) {
2079 px = mid_pred(A[0], B[0], C[0]);
2080 py = mid_pred(A[1], B[1], C[1]);
2082 } else if (s->mb_x) { // predictor C is not out of bounds
2088 /* Pullback MV as specified in 8.3.5.3.4 */
2091 if (v->profile < PROFILE_ADVANCED) {
2092 qx = (s->mb_x << 5);
2093 qy = (s->mb_y << 5);
2094 X = (s->mb_width << 5) - 4;
2095 Y = (s->mb_height << 5) - 4;
2096 if (qx + px < -28) px = -28 - qx;
2097 if (qy + py < -28) py = -28 - qy;
2098 if (qx + px > X) px = X - qx;
2099 if (qy + py > Y) py = Y - qy;
2101 qx = (s->mb_x << 6);
2102 qy = (s->mb_y << 6);
2103 X = (s->mb_width << 6) - 4;
2104 Y = (s->mb_height << 6) - 4;
2105 if (qx + px < -60) px = -60 - qx;
2106 if (qy + py < -60) py = -60 - qy;
2107 if (qx + px > X) px = X - qx;
2108 if (qy + py > Y) py = Y - qy;
2111 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2112 if (0 && !s->first_slice_line && s->mb_x) {
2113 if (is_intra[xy - wrap])
2114 sum = FFABS(px) + FFABS(py);
2116 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2118 if (get_bits1(&s->gb)) {
2126 if (is_intra[xy - 2])
2127 sum = FFABS(px) + FFABS(py);
2129 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2131 if (get_bits1(&s->gb)) {
2141 /* store MV using signed modulus of MV range defined in 4.11 */
2142 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2143 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2145 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2146 C = s->current_picture.f.motion_val[1][xy - 2];
2147 A = s->current_picture.f.motion_val[1][xy - wrap * 2];
2148 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2149 B = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
2153 if (!s->first_slice_line) { // predictor A is not out of bounds
2154 if (s->mb_width == 1) {
2158 px = mid_pred(A[0], B[0], C[0]);
2159 py = mid_pred(A[1], B[1], C[1]);
2161 } else if (s->mb_x) { // predictor C is not out of bounds
2167 /* Pullback MV as specified in 8.3.5.3.4 */
2170 if (v->profile < PROFILE_ADVANCED) {
2171 qx = (s->mb_x << 5);
2172 qy = (s->mb_y << 5);
2173 X = (s->mb_width << 5) - 4;
2174 Y = (s->mb_height << 5) - 4;
2175 if (qx + px < -28) px = -28 - qx;
2176 if (qy + py < -28) py = -28 - qy;
2177 if (qx + px > X) px = X - qx;
2178 if (qy + py > Y) py = Y - qy;
2180 qx = (s->mb_x << 6);
2181 qy = (s->mb_y << 6);
2182 X = (s->mb_width << 6) - 4;
2183 Y = (s->mb_height << 6) - 4;
2184 if (qx + px < -60) px = -60 - qx;
2185 if (qy + py < -60) py = -60 - qy;
2186 if (qx + px > X) px = X - qx;
2187 if (qy + py > Y) py = Y - qy;
2190 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2191 if (0 && !s->first_slice_line && s->mb_x) {
2192 if (is_intra[xy - wrap])
2193 sum = FFABS(px) + FFABS(py);
2195 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2197 if (get_bits1(&s->gb)) {
2205 if (is_intra[xy - 2])
2206 sum = FFABS(px) + FFABS(py);
2208 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2210 if (get_bits1(&s->gb)) {
2220 /* store MV using signed modulus of MV range defined in 4.11 */
2222 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2223 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2225 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
2226 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
2227 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
2228 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
2231 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2233 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2234 MpegEncContext *s = &v->s;
2235 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2237 if (v->bmvtype == BMV_TYPE_DIRECT) {
2238 int total_opp, k, f;
2239 if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2240 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2241 v->bfraction, 0, s->quarter_sample);
2242 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2243 v->bfraction, 0, s->quarter_sample);
2244 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2245 v->bfraction, 1, s->quarter_sample);
2246 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2247 v->bfraction, 1, s->quarter_sample);
2249 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2250 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2251 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2252 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2253 f = (total_opp > 2) ? 1 : 0;
2255 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2256 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2259 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2260 for (k = 0; k < 4; k++) {
2261 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2262 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2263 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2264 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2265 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2266 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2270 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2271 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);
2272 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);
2275 if (dir) { // backward
2276 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);
2277 if (n == 3 || mv1) {
2278 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2281 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);
2282 if (n == 3 || mv1) {
2283 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2288 /** Get predicted DC value for I-frames only
2289 * prediction dir: left=0, top=1
2290 * @param s MpegEncContext
2291 * @param overlap flag indicating that overlap filtering is used
2292 * @param pq integer part of picture quantizer
2293 * @param[in] n block index in the current MB
2294 * @param dc_val_ptr Pointer to DC predictor
2295 * @param dir_ptr Prediction direction for use in AC prediction
2297 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2298 int16_t **dc_val_ptr, int *dir_ptr)
2300 int a, b, c, wrap, pred, scale;
2302 static const uint16_t dcpred[32] = {
2303 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2304 114, 102, 93, 85, 79, 73, 68, 64,
2305 60, 57, 54, 51, 49, 47, 45, 43,
2306 41, 39, 38, 37, 35, 34, 33
2309 /* find prediction - wmv3_dc_scale always used here in fact */
2310 if (n < 4) scale = s->y_dc_scale;
2311 else scale = s->c_dc_scale;
2313 wrap = s->block_wrap[n];
2314 dc_val = s->dc_val[0] + s->block_index[n];
2320 b = dc_val[ - 1 - wrap];
2321 a = dc_val[ - wrap];
2323 if (pq < 9 || !overlap) {
2324 /* Set outer values */
2325 if (s->first_slice_line && (n != 2 && n != 3))
2326 b = a = dcpred[scale];
2327 if (s->mb_x == 0 && (n != 1 && n != 3))
2328 b = c = dcpred[scale];
2330 /* Set outer values */
2331 if (s->first_slice_line && (n != 2 && n != 3))
2333 if (s->mb_x == 0 && (n != 1 && n != 3))
2337 if (abs(a - b) <= abs(b - c)) {
2339 *dir_ptr = 1; // left
2342 *dir_ptr = 0; // top
2345 /* update predictor */
2346 *dc_val_ptr = &dc_val[0];
2351 /** Get predicted DC value
2352 * prediction dir: left=0, top=1
2353 * @param s MpegEncContext
2354 * @param overlap flag indicating that overlap filtering is used
2355 * @param pq integer part of picture quantizer
2356 * @param[in] n block index in the current MB
2357 * @param a_avail flag indicating top block availability
2358 * @param c_avail flag indicating left block availability
2359 * @param dc_val_ptr Pointer to DC predictor
2360 * @param dir_ptr Prediction direction for use in AC prediction
2362 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2363 int a_avail, int c_avail,
2364 int16_t **dc_val_ptr, int *dir_ptr)
2366 int a, b, c, wrap, pred;
2368 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2372 wrap = s->block_wrap[n];
2373 dc_val = s->dc_val[0] + s->block_index[n];
2379 b = dc_val[ - 1 - wrap];
2380 a = dc_val[ - wrap];
2381 /* scale predictors if needed */
2382 q1 = s->current_picture.f.qscale_table[mb_pos];
2383 dqscale_index = s->y_dc_scale_table[q1] - 1;
2384 if (dqscale_index < 0)
2386 if (c_avail && (n != 1 && n != 3)) {
2387 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2389 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2391 if (a_avail && (n != 2 && n != 3)) {
2392 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2394 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2396 if (a_avail && c_avail && (n != 3)) {
2401 off -= s->mb_stride;
2402 q2 = s->current_picture.f.qscale_table[off];
2404 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2407 if (a_avail && c_avail) {
2408 if (abs(a - b) <= abs(b - c)) {
2410 *dir_ptr = 1; // left
2413 *dir_ptr = 0; // top
2415 } else if (a_avail) {
2417 *dir_ptr = 0; // top
2418 } else if (c_avail) {
2420 *dir_ptr = 1; // left
2423 *dir_ptr = 1; // left
2426 /* update predictor */
2427 *dc_val_ptr = &dc_val[0];
2431 /** @} */ // Block group
2434 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2435 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2439 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2440 uint8_t **coded_block_ptr)
2442 int xy, wrap, pred, a, b, c;
2444 xy = s->block_index[n];
2445 wrap = s->b8_stride;
2450 a = s->coded_block[xy - 1 ];
2451 b = s->coded_block[xy - 1 - wrap];
2452 c = s->coded_block[xy - wrap];
2461 *coded_block_ptr = &s->coded_block[xy];
2467 * Decode one AC coefficient
2468 * @param v The VC1 context
2469 * @param last Last coefficient
2470 * @param skip How much zero coefficients to skip
2471 * @param value Decoded AC coefficient value
2472 * @param codingset set of VLC to decode data
2475 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2476 int *value, int codingset)
2478 GetBitContext *gb = &v->s.gb;
2479 int index, escape, run = 0, level = 0, lst = 0;
2481 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2482 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2483 run = vc1_index_decode_table[codingset][index][0];
2484 level = vc1_index_decode_table[codingset][index][1];
2485 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2489 escape = decode210(gb);
2491 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2492 run = vc1_index_decode_table[codingset][index][0];
2493 level = vc1_index_decode_table[codingset][index][1];
2494 lst = index >= vc1_last_decode_table[codingset];
2497 level += vc1_last_delta_level_table[codingset][run];
2499 level += vc1_delta_level_table[codingset][run];
2502 run += vc1_last_delta_run_table[codingset][level] + 1;
2504 run += vc1_delta_run_table[codingset][level] + 1;
2510 lst = get_bits1(gb);
2511 if (v->s.esc3_level_length == 0) {
2512 if (v->pq < 8 || v->dquantfrm) { // table 59
2513 v->s.esc3_level_length = get_bits(gb, 3);
2514 if (!v->s.esc3_level_length)
2515 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2516 } else { // table 60
2517 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2519 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2521 run = get_bits(gb, v->s.esc3_run_length);
2522 sign = get_bits1(gb);
2523 level = get_bits(gb, v->s.esc3_level_length);
2534 /** Decode intra block in intra frames - should be faster than decode_intra_block
2535 * @param v VC1Context
2536 * @param block block to decode
2537 * @param[in] n subblock index
2538 * @param coded are AC coeffs present or not
2539 * @param codingset set of VLC to decode data
2541 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
2542 int coded, int codingset)
2544 GetBitContext *gb = &v->s.gb;
2545 MpegEncContext *s = &v->s;
2546 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2549 int16_t *ac_val, *ac_val2;
2552 /* Get DC differential */
2554 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2556 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2559 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2563 if (dcdiff == 119 /* ESC index value */) {
2564 /* TODO: Optimize */
2565 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2566 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2567 else dcdiff = get_bits(gb, 8);
2570 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2571 else if (v->pq == 2)
2572 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2579 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2582 /* Store the quantized DC coeff, used for prediction */
2584 block[0] = dcdiff * s->y_dc_scale;
2586 block[0] = dcdiff * s->c_dc_scale;
2597 int last = 0, skip, value;
2598 const uint8_t *zz_table;
2602 scale = v->pq * 2 + v->halfpq;
2606 zz_table = v->zz_8x8[2];
2608 zz_table = v->zz_8x8[3];
2610 zz_table = v->zz_8x8[1];
2612 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2614 if (dc_pred_dir) // left
2617 ac_val -= 16 * s->block_wrap[n];
2620 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2624 block[zz_table[i++]] = value;
2627 /* apply AC prediction if needed */
2629 if (dc_pred_dir) { // left
2630 for (k = 1; k < 8; k++)
2631 block[k << v->left_blk_sh] += ac_val[k];
2633 for (k = 1; k < 8; k++)
2634 block[k << v->top_blk_sh] += ac_val[k + 8];
2637 /* save AC coeffs for further prediction */
2638 for (k = 1; k < 8; k++) {
2639 ac_val2[k] = block[k << v->left_blk_sh];
2640 ac_val2[k + 8] = block[k << v->top_blk_sh];
2643 /* scale AC coeffs */
2644 for (k = 1; k < 64; k++)
2648 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2651 if (s->ac_pred) i = 63;
2657 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2661 scale = v->pq * 2 + v->halfpq;
2662 memset(ac_val2, 0, 16 * 2);
2663 if (dc_pred_dir) { // left
2666 memcpy(ac_val2, ac_val, 8 * 2);
2668 ac_val -= 16 * s->block_wrap[n];
2670 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2673 /* apply AC prediction if needed */
2675 if (dc_pred_dir) { //left
2676 for (k = 1; k < 8; k++) {
2677 block[k << v->left_blk_sh] = ac_val[k] * scale;
2678 if (!v->pquantizer && block[k << v->left_blk_sh])
2679 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2682 for (k = 1; k < 8; k++) {
2683 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2684 if (!v->pquantizer && block[k << v->top_blk_sh])
2685 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2691 s->block_last_index[n] = i;
2696 /** Decode intra block in intra frames - should be faster than decode_intra_block
2697 * @param v VC1Context
2698 * @param block block to decode
2699 * @param[in] n subblock number
2700 * @param coded are AC coeffs present or not
2701 * @param codingset set of VLC to decode data
2702 * @param mquant quantizer value for this macroblock
2704 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
2705 int coded, int codingset, int mquant)
2707 GetBitContext *gb = &v->s.gb;
2708 MpegEncContext *s = &v->s;
2709 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2712 int16_t *ac_val, *ac_val2;
2714 int a_avail = v->a_avail, c_avail = v->c_avail;
2715 int use_pred = s->ac_pred;
2718 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2720 /* Get DC differential */
2722 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2724 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2727 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2731 if (dcdiff == 119 /* ESC index value */) {
2732 /* TODO: Optimize */
2733 if (mquant == 1) dcdiff = get_bits(gb, 10);
2734 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2735 else dcdiff = get_bits(gb, 8);
2738 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2739 else if (mquant == 2)
2740 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2747 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2750 /* Store the quantized DC coeff, used for prediction */
2752 block[0] = dcdiff * s->y_dc_scale;
2754 block[0] = dcdiff * s->c_dc_scale;
2760 /* check if AC is needed at all */
2761 if (!a_avail && !c_avail)
2763 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2766 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2768 if (dc_pred_dir) // left
2771 ac_val -= 16 * s->block_wrap[n];
2773 q1 = s->current_picture.f.qscale_table[mb_pos];
2774 if ( dc_pred_dir && c_avail && mb_pos)
2775 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2776 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2777 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2778 if ( dc_pred_dir && n == 1)
2780 if (!dc_pred_dir && n == 2)
2786 int last = 0, skip, value;
2787 const uint8_t *zz_table;
2791 if (!use_pred && v->fcm == ILACE_FRAME) {
2792 zz_table = v->zzi_8x8;
2794 if (!dc_pred_dir) // top
2795 zz_table = v->zz_8x8[2];
2797 zz_table = v->zz_8x8[3];
2800 if (v->fcm != ILACE_FRAME)
2801 zz_table = v->zz_8x8[1];
2803 zz_table = v->zzi_8x8;
2807 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2811 block[zz_table[i++]] = value;
2814 /* apply AC prediction if needed */
2816 /* scale predictors if needed*/
2817 if (q2 && q1 != q2) {
2818 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2819 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2822 return AVERROR_INVALIDDATA;
2823 if (dc_pred_dir) { // left
2824 for (k = 1; k < 8; k++)
2825 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2827 for (k = 1; k < 8; k++)
2828 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2831 if (dc_pred_dir) { //left
2832 for (k = 1; k < 8; k++)
2833 block[k << v->left_blk_sh] += ac_val[k];
2835 for (k = 1; k < 8; k++)
2836 block[k << v->top_blk_sh] += ac_val[k + 8];
2840 /* save AC coeffs for further prediction */
2841 for (k = 1; k < 8; k++) {
2842 ac_val2[k ] = block[k << v->left_blk_sh];
2843 ac_val2[k + 8] = block[k << v->top_blk_sh];
2846 /* scale AC coeffs */
2847 for (k = 1; k < 64; k++)
2851 block[k] += (block[k] < 0) ? -mquant : mquant;
2854 if (use_pred) i = 63;
2855 } else { // no AC coeffs
2858 memset(ac_val2, 0, 16 * 2);
2859 if (dc_pred_dir) { // left
2861 memcpy(ac_val2, ac_val, 8 * 2);
2862 if (q2 && q1 != q2) {
2863 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2864 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2866 return AVERROR_INVALIDDATA;
2867 for (k = 1; k < 8; k++)
2868 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2873 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2874 if (q2 && q1 != q2) {
2875 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2876 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2878 return AVERROR_INVALIDDATA;
2879 for (k = 1; k < 8; k++)
2880 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2885 /* apply AC prediction if needed */
2887 if (dc_pred_dir) { // left
2888 for (k = 1; k < 8; k++) {
2889 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2890 if (!v->pquantizer && block[k << v->left_blk_sh])
2891 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2894 for (k = 1; k < 8; k++) {
2895 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2896 if (!v->pquantizer && block[k << v->top_blk_sh])
2897 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2903 s->block_last_index[n] = i;
2908 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2909 * @param v VC1Context
2910 * @param block block to decode
2911 * @param[in] n subblock index
2912 * @param coded are AC coeffs present or not
2913 * @param mquant block quantizer
2914 * @param codingset set of VLC to decode data
2916 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
2917 int coded, int mquant, int codingset)
2919 GetBitContext *gb = &v->s.gb;
2920 MpegEncContext *s = &v->s;
2921 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2924 int16_t *ac_val, *ac_val2;
2926 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2927 int a_avail = v->a_avail, c_avail = v->c_avail;
2928 int use_pred = s->ac_pred;
2932 s->dsp.clear_block(block);
2934 /* XXX: Guard against dumb values of mquant */
2935 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2937 /* Set DC scale - y and c use the same */
2938 s->y_dc_scale = s->y_dc_scale_table[mquant];
2939 s->c_dc_scale = s->c_dc_scale_table[mquant];
2941 /* Get DC differential */
2943 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2945 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2948 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2952 if (dcdiff == 119 /* ESC index value */) {
2953 /* TODO: Optimize */
2954 if (mquant == 1) dcdiff = get_bits(gb, 10);
2955 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2956 else dcdiff = get_bits(gb, 8);
2959 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2960 else if (mquant == 2)
2961 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2968 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2971 /* Store the quantized DC coeff, used for prediction */
2974 block[0] = dcdiff * s->y_dc_scale;
2976 block[0] = dcdiff * s->c_dc_scale;
2982 /* check if AC is needed at all and adjust direction if needed */
2983 if (!a_avail) dc_pred_dir = 1;
2984 if (!c_avail) dc_pred_dir = 0;
2985 if (!a_avail && !c_avail) use_pred = 0;
2986 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2989 scale = mquant * 2 + v->halfpq;
2991 if (dc_pred_dir) //left
2994 ac_val -= 16 * s->block_wrap[n];
2996 q1 = s->current_picture.f.qscale_table[mb_pos];
2997 if (dc_pred_dir && c_avail && mb_pos)
2998 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2999 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3000 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
3001 if ( dc_pred_dir && n == 1)
3003 if (!dc_pred_dir && n == 2)
3005 if (n == 3) q2 = q1;
3008 int last = 0, skip, value;
3012 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3016 if (v->fcm == PROGRESSIVE)
3017 block[v->zz_8x8[0][i++]] = value;
3019 if (use_pred && (v->fcm == ILACE_FRAME)) {
3020 if (!dc_pred_dir) // top
3021 block[v->zz_8x8[2][i++]] = value;
3023 block[v->zz_8x8[3][i++]] = value;
3025 block[v->zzi_8x8[i++]] = value;
3030 /* apply AC prediction if needed */
3032 /* scale predictors if needed*/
3033 if (q2 && q1 != q2) {
3034 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3035 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3038 return AVERROR_INVALIDDATA;
3039 if (dc_pred_dir) { // left
3040 for (k = 1; k < 8; k++)
3041 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3043 for (k = 1; k < 8; k++)
3044 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3047 if (dc_pred_dir) { // left
3048 for (k = 1; k < 8; k++)
3049 block[k << v->left_blk_sh] += ac_val[k];
3051 for (k = 1; k < 8; k++)
3052 block[k << v->top_blk_sh] += ac_val[k + 8];
3056 /* save AC coeffs for further prediction */
3057 for (k = 1; k < 8; k++) {
3058 ac_val2[k ] = block[k << v->left_blk_sh];
3059 ac_val2[k + 8] = block[k << v->top_blk_sh];
3062 /* scale AC coeffs */
3063 for (k = 1; k < 64; k++)
3067 block[k] += (block[k] < 0) ? -mquant : mquant;
3070 if (use_pred) i = 63;
3071 } else { // no AC coeffs
3074 memset(ac_val2, 0, 16 * 2);
3075 if (dc_pred_dir) { // left
3077 memcpy(ac_val2, ac_val, 8 * 2);
3078 if (q2 && q1 != q2) {
3079 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3080 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3082 return AVERROR_INVALIDDATA;
3083 for (k = 1; k < 8; k++)
3084 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3089 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3090 if (q2 && q1 != q2) {
3091 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3092 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3094 return AVERROR_INVALIDDATA;
3095 for (k = 1; k < 8; k++)
3096 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3101 /* apply AC prediction if needed */
3103 if (dc_pred_dir) { // left
3104 for (k = 1; k < 8; k++) {
3105 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3106 if (!v->pquantizer && block[k << v->left_blk_sh])
3107 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3110 for (k = 1; k < 8; k++) {
3111 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3112 if (!v->pquantizer && block[k << v->top_blk_sh])
3113 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3119 s->block_last_index[n] = i;
3126 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
3127 int mquant, int ttmb, int first_block,
3128 uint8_t *dst, int linesize, int skip_block,
3131 MpegEncContext *s = &v->s;
3132 GetBitContext *gb = &s->gb;
3135 int scale, off, idx, last, skip, value;
3136 int ttblk = ttmb & 7;
3139 s->dsp.clear_block(block);
3142 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)];
3144 if (ttblk == TT_4X4) {
3145 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3147 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3148 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3149 || (!v->res_rtm_flag && !first_block))) {
3150 subblkpat = decode012(gb);
3152 subblkpat ^= 3; // swap decoded pattern bits
3153 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3155 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3158 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3160 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3161 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3162 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3165 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3166 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3175 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3180 idx = v->zz_8x8[0][i++];
3182 idx = v->zzi_8x8[i++];
3183 block[idx] = value * scale;
3185 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3189 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3191 v->vc1dsp.vc1_inv_trans_8x8(block);
3192 s->dsp.add_pixels_clamped(block, dst, linesize);
3197 pat = ~subblkpat & 0xF;
3198 for (j = 0; j < 4; j++) {
3199 last = subblkpat & (1 << (3 - j));
3201 off = (j & 1) * 4 + (j & 2) * 16;
3203 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3208 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3210 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3211 block[idx + off] = value * scale;
3213 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3215 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3217 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3219 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3224 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3225 for (j = 0; j < 2; j++) {
3226 last = subblkpat & (1 << (1 - j));
3230 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3235 idx = v->zz_8x4[i++] + off;
3237 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3238 block[idx] = value * scale;
3240 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3242 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3244 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3246 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3251 pat = ~(subblkpat * 5) & 0xF;
3252 for (j = 0; j < 2; j++) {
3253 last = subblkpat & (1 << (1 - j));
3257 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3262 idx = v->zz_4x8[i++] + off;
3264 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3265 block[idx] = value * scale;
3267 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3269 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3271 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3273 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3279 *ttmb_out |= ttblk << (n * 4);
3283 /** @} */ // Macroblock group
3285 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3286 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3288 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3290 MpegEncContext *s = &v->s;
3291 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3292 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3293 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3294 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3295 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3298 if (block_num > 3) {
3299 dst = s->dest[block_num - 3];
3301 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3303 if (s->mb_y != s->end_mb_y || block_num < 2) {
3307 if (block_num > 3) {
3308 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3309 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3310 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3311 mv_stride = s->mb_stride;
3313 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3314 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3315 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3316 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3317 mv_stride = s->b8_stride;
3318 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3321 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3322 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3323 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3325 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3327 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3330 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3332 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3337 dst -= 4 * linesize;
3338 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3339 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3340 idx = (block_cbp | (block_cbp >> 2)) & 3;
3342 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3345 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3347 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3352 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3354 MpegEncContext *s = &v->s;
3355 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3356 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3357 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3358 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3359 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3362 if (block_num > 3) {
3363 dst = s->dest[block_num - 3] - 8 * linesize;
3365 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3368 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3371 if (block_num > 3) {
3372 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3373 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3374 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3376 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3377 : (mb_cbp >> ((block_num + 1) * 4));
3378 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3379 : (mb_is_intra >> ((block_num + 1) * 4));
3380 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3382 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3383 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3385 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3387 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3390 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3392 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3398 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3399 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3400 idx = (block_cbp | (block_cbp >> 1)) & 5;
3402 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3405 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3407 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3412 static void vc1_apply_p_loop_filter(VC1Context *v)
3414 MpegEncContext *s = &v->s;
3417 for (i = 0; i < 6; i++) {
3418 vc1_apply_p_v_loop_filter(v, i);
3421 /* V always precedes H, therefore we run H one MB before V;
3422 * at the end of a row, we catch up to complete the row */
3424 for (i = 0; i < 6; i++) {
3425 vc1_apply_p_h_loop_filter(v, i);
3427 if (s->mb_x == s->mb_width - 1) {
3429 ff_update_block_index(s);
3430 for (i = 0; i < 6; i++) {
3431 vc1_apply_p_h_loop_filter(v, i);
3437 /** Decode one P-frame MB
3439 static int vc1_decode_p_mb(VC1Context *v)
3441 MpegEncContext *s = &v->s;
3442 GetBitContext *gb = &s->gb;
3444 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3445 int cbp; /* cbp decoding stuff */
3446 int mqdiff, mquant; /* MB quantization */
3447 int ttmb = v->ttfrm; /* MB Transform type */
3449 int mb_has_coeffs = 1; /* last_flag */
3450 int dmv_x, dmv_y; /* Differential MV components */
3451 int index, index1; /* LUT indexes */
3452 int val, sign; /* temp values */
3453 int first_block = 1;
3455 int skipped, fourmv;
3456 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3458 mquant = v->pq; /* lossy initialization */
3460 if (v->mv_type_is_raw)
3461 fourmv = get_bits1(gb);
3463 fourmv = v->mv_type_mb_plane[mb_pos];
3465 skipped = get_bits1(gb);
3467 skipped = v->s.mbskip_table[mb_pos];
3469 if (!fourmv) { /* 1MV mode */
3471 GET_MVDATA(dmv_x, dmv_y);
3474 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3475 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3477 s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3478 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3480 /* FIXME Set DC val for inter block ? */
3481 if (s->mb_intra && !mb_has_coeffs) {
3483 s->ac_pred = get_bits1(gb);
3485 } else if (mb_has_coeffs) {
3487 s->ac_pred = get_bits1(gb);
3488 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3494 s->current_picture.f.qscale_table[mb_pos] = mquant;
3496 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3497 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3498 VC1_TTMB_VLC_BITS, 2);
3499 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3501 for (i = 0; i < 6; i++) {
3502 s->dc_val[0][s->block_index[i]] = 0;
3504 val = ((cbp >> (5 - i)) & 1);
3505 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3506 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3508 /* check if prediction blocks A and C are available */
3509 v->a_avail = v->c_avail = 0;
3510 if (i == 2 || i == 3 || !s->first_slice_line)
3511 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3512 if (i == 1 || i == 3 || s->mb_x)
3513 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3515 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3516 (i & 4) ? v->codingset2 : v->codingset);
3517 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3519 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3521 for (j = 0; j < 64; j++)
3522 s->block[i][j] <<= 1;
3523 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3524 if (v->pq >= 9 && v->overlap) {
3526 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3528 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3530 block_cbp |= 0xF << (i << 2);
3531 block_intra |= 1 << i;
3533 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3534 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3535 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3536 block_cbp |= pat << (i << 2);
3537 if (!v->ttmbf && ttmb < 8)
3544 for (i = 0; i < 6; i++) {
3545 v->mb_type[0][s->block_index[i]] = 0;
3546 s->dc_val[0][s->block_index[i]] = 0;
3548 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3549 s->current_picture.f.qscale_table[mb_pos] = 0;
3550 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3553 } else { // 4MV mode
3554 if (!skipped /* unskipped MB */) {
3555 int intra_count = 0, coded_inter = 0;
3556 int is_intra[6], is_coded[6];
3558 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3559 for (i = 0; i < 6; i++) {
3560 val = ((cbp >> (5 - i)) & 1);
3561 s->dc_val[0][s->block_index[i]] = 0;
3568 GET_MVDATA(dmv_x, dmv_y);
3570 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3572 vc1_mc_4mv_luma(v, i, 0);
3573 intra_count += s->mb_intra;
3574 is_intra[i] = s->mb_intra;
3575 is_coded[i] = mb_has_coeffs;
3578 is_intra[i] = (intra_count >= 3);
3582 vc1_mc_4mv_chroma(v, 0);
3583 v->mb_type[0][s->block_index[i]] = is_intra[i];
3585 coded_inter = !is_intra[i] & is_coded[i];
3587 // if there are no coded blocks then don't do anything more
3589 if (!intra_count && !coded_inter)
3592 s->current_picture.f.qscale_table[mb_pos] = mquant;
3593 /* test if block is intra and has pred */
3596 for (i = 0; i < 6; i++)
3598 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3599 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3605 s->ac_pred = get_bits1(gb);
3609 if (!v->ttmbf && coded_inter)
3610 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3611 for (i = 0; i < 6; i++) {
3613 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3614 s->mb_intra = is_intra[i];
3616 /* check if prediction blocks A and C are available */
3617 v->a_avail = v->c_avail = 0;
3618 if (i == 2 || i == 3 || !s->first_slice_line)
3619 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3620 if (i == 1 || i == 3 || s->mb_x)
3621 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3623 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3624 (i & 4) ? v->codingset2 : v->codingset);
3625 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3627 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3629 for (j = 0; j < 64; j++)
3630 s->block[i][j] <<= 1;
3631 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3632 (i & 4) ? s->uvlinesize : s->linesize);
3633 if (v->pq >= 9 && v->overlap) {
3635 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3637 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3639 block_cbp |= 0xF << (i << 2);
3640 block_intra |= 1 << i;
3641 } else if (is_coded[i]) {
3642 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3643 first_block, s->dest[dst_idx] + off,
3644 (i & 4) ? s->uvlinesize : s->linesize,
3645 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3647 block_cbp |= pat << (i << 2);
3648 if (!v->ttmbf && ttmb < 8)
3653 } else { // skipped MB
3655 s->current_picture.f.qscale_table[mb_pos] = 0;
3656 for (i = 0; i < 6; i++) {
3657 v->mb_type[0][s->block_index[i]] = 0;
3658 s->dc_val[0][s->block_index[i]] = 0;
3660 for (i = 0; i < 4; i++) {
3661 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3662 vc1_mc_4mv_luma(v, i, 0);
3664 vc1_mc_4mv_chroma(v, 0);
3665 s->current_picture.f.qscale_table[mb_pos] = 0;
3669 v->cbp[s->mb_x] = block_cbp;
3670 v->ttblk[s->mb_x] = block_tt;
3671 v->is_intra[s->mb_x] = block_intra;
3676 /* Decode one macroblock in an interlaced frame p picture */
3678 static int vc1_decode_p_mb_intfr(VC1Context *v)
3680 MpegEncContext *s = &v->s;
3681 GetBitContext *gb = &s->gb;
3683 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3684 int cbp = 0; /* cbp decoding stuff */
3685 int mqdiff, mquant; /* MB quantization */
3686 int ttmb = v->ttfrm; /* MB Transform type */
3688 int mb_has_coeffs = 1; /* last_flag */
3689 int dmv_x, dmv_y; /* Differential MV components */
3690 int val; /* temp value */
3691 int first_block = 1;
3693 int skipped, fourmv = 0, twomv = 0;
3694 int block_cbp = 0, pat, block_tt = 0;
3695 int idx_mbmode = 0, mvbp;
3696 int stride_y, fieldtx;
3698 mquant = v->pq; /* Lossy initialization */
3701 skipped = get_bits1(gb);
3703 skipped = v->s.mbskip_table[mb_pos];
3705 if (v->fourmvswitch)
3706 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3708 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3709 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3710 /* store the motion vector type in a flag (useful later) */
3711 case MV_PMODE_INTFR_4MV:
3713 v->blk_mv_type[s->block_index[0]] = 0;
3714 v->blk_mv_type[s->block_index[1]] = 0;
3715 v->blk_mv_type[s->block_index[2]] = 0;
3716 v->blk_mv_type[s->block_index[3]] = 0;
3718 case MV_PMODE_INTFR_4MV_FIELD:
3720 v->blk_mv_type[s->block_index[0]] = 1;
3721 v->blk_mv_type[s->block_index[1]] = 1;
3722 v->blk_mv_type[s->block_index[2]] = 1;
3723 v->blk_mv_type[s->block_index[3]] = 1;
3725 case MV_PMODE_INTFR_2MV_FIELD:
3727 v->blk_mv_type[s->block_index[0]] = 1;
3728 v->blk_mv_type[s->block_index[1]] = 1;
3729 v->blk_mv_type[s->block_index[2]] = 1;
3730 v->blk_mv_type[s->block_index[3]] = 1;
3732 case MV_PMODE_INTFR_1MV:
3733 v->blk_mv_type[s->block_index[0]] = 0;
3734 v->blk_mv_type[s->block_index[1]] = 0;
3735 v->blk_mv_type[s->block_index[2]] = 0;
3736 v->blk_mv_type[s->block_index[3]] = 0;
3739 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3740 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3741 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3742 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
3743 s->mb_intra = v->is_intra[s->mb_x] = 1;
3744 for (i = 0; i < 6; i++)
3745 v->mb_type[0][s->block_index[i]] = 1;
3746 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3747 mb_has_coeffs = get_bits1(gb);
3749 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3750 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3752 s->current_picture.f.qscale_table[mb_pos] = mquant;
3753 /* Set DC scale - y and c use the same (not sure if necessary here) */
3754 s->y_dc_scale = s->y_dc_scale_table[mquant];
3755 s->c_dc_scale = s->c_dc_scale_table[mquant];
3757 for (i = 0; i < 6; i++) {
3758 s->dc_val[0][s->block_index[i]] = 0;
3760 val = ((cbp >> (5 - i)) & 1);
3761 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3762 v->a_avail = v->c_avail = 0;
3763 if (i == 2 || i == 3 || !s->first_slice_line)
3764 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3765 if (i == 1 || i == 3 || s->mb_x)
3766 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3768 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3769 (i & 4) ? v->codingset2 : v->codingset);
3770 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3771 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3773 stride_y = s->linesize << fieldtx;
3774 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3776 stride_y = s->uvlinesize;
3779 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3783 } else { // inter MB
3784 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3786 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3787 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3788 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3790 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3791 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3792 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3795 s->mb_intra = v->is_intra[s->mb_x] = 0;
3796 for (i = 0; i < 6; i++)
3797 v->mb_type[0][s->block_index[i]] = 0;
3798 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3799 /* for all motion vector read MVDATA and motion compensate each block */
3803 for (i = 0; i < 6; i++) {
3806 val = ((mvbp >> (3 - i)) & 1);
3808 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3810 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3811 vc1_mc_4mv_luma(v, i, 0);
3812 } else if (i == 4) {
3813 vc1_mc_4mv_chroma4(v);
3820 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3822 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3823 vc1_mc_4mv_luma(v, 0, 0);
3824 vc1_mc_4mv_luma(v, 1, 0);
3827 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3829 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3830 vc1_mc_4mv_luma(v, 2, 0);
3831 vc1_mc_4mv_luma(v, 3, 0);
3832 vc1_mc_4mv_chroma4(v);
3834 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3837 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3839 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3843 GET_MQUANT(); // p. 227
3844 s->current_picture.f.qscale_table[mb_pos] = mquant;
3845 if (!v->ttmbf && cbp)
3846 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3847 for (i = 0; i < 6; i++) {
3848 s->dc_val[0][s->block_index[i]] = 0;
3850 val = ((cbp >> (5 - i)) & 1);
3852 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3854 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3856 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3857 first_block, s->dest[dst_idx] + off,
3858 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3859 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3860 block_cbp |= pat << (i << 2);
3861 if (!v->ttmbf && ttmb < 8)
3868 s->mb_intra = v->is_intra[s->mb_x] = 0;
3869 for (i = 0; i < 6; i++) {
3870 v->mb_type[0][s->block_index[i]] = 0;
3871 s->dc_val[0][s->block_index[i]] = 0;
3873 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3874 s->current_picture.f.qscale_table[mb_pos] = 0;
3875 v->blk_mv_type[s->block_index[0]] = 0;
3876 v->blk_mv_type[s->block_index[1]] = 0;
3877 v->blk_mv_type[s->block_index[2]] = 0;
3878 v->blk_mv_type[s->block_index[3]] = 0;
3879 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3882 if (s->mb_x == s->mb_width - 1)
3883 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3887 static int vc1_decode_p_mb_intfi(VC1Context *v)
3889 MpegEncContext *s = &v->s;
3890 GetBitContext *gb = &s->gb;
3892 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3893 int cbp = 0; /* cbp decoding stuff */
3894 int mqdiff, mquant; /* MB quantization */
3895 int ttmb = v->ttfrm; /* MB Transform type */
3897 int mb_has_coeffs = 1; /* last_flag */
3898 int dmv_x, dmv_y; /* Differential MV components */
3899 int val; /* temp values */
3900 int first_block = 1;
3903 int block_cbp = 0, pat, block_tt = 0;
3906 mquant = v->pq; /* Lossy initialization */
3908 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3909 if (idx_mbmode <= 1) { // intra MB
3910 s->mb_intra = v->is_intra[s->mb_x] = 1;
3911 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3912 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3913 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3915 s->current_picture.f.qscale_table[mb_pos] = mquant;
3916 /* Set DC scale - y and c use the same (not sure if necessary here) */
3917 s->y_dc_scale = s->y_dc_scale_table[mquant];
3918 s->c_dc_scale = s->c_dc_scale_table[mquant];
3919 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3920 mb_has_coeffs = idx_mbmode & 1;
3922 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3924 for (i = 0; i < 6; i++) {
3925 s->dc_val[0][s->block_index[i]] = 0;
3926 v->mb_type[0][s->block_index[i]] = 1;
3928 val = ((cbp >> (5 - i)) & 1);
3929 v->a_avail = v->c_avail = 0;
3930 if (i == 2 || i == 3 || !s->first_slice_line)
3931 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3932 if (i == 1 || i == 3 || s->mb_x)
3933 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3935 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3936 (i & 4) ? v->codingset2 : v->codingset);
3937 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3939 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3940 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3941 off += v->second_field ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
3942 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
3943 // TODO: loop filter
3946 s->mb_intra = v->is_intra[s->mb_x] = 0;
3947 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3948 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3949 if (idx_mbmode <= 5) { // 1-MV
3950 dmv_x = dmv_y = pred_flag = 0;
3951 if (idx_mbmode & 1) {
3952 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3954 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3956 mb_has_coeffs = !(idx_mbmode & 2);
3958 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3959 for (i = 0; i < 6; i++) {
3961 dmv_x = dmv_y = pred_flag = 0;
3962 val = ((v->fourmvbp >> (3 - i)) & 1);
3964 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3966 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3967 vc1_mc_4mv_luma(v, i, 0);
3969 vc1_mc_4mv_chroma(v, 0);
3971 mb_has_coeffs = idx_mbmode & 1;
3974 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3978 s->current_picture.f.qscale_table[mb_pos] = mquant;
3979 if (!v->ttmbf && cbp) {
3980 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3983 for (i = 0; i < 6; i++) {
3984 s->dc_val[0][s->block_index[i]] = 0;
3986 val = ((cbp >> (5 - i)) & 1);
3987 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
3988 if (v->second_field)
3989 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
3991 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3992 first_block, s->dest[dst_idx] + off,
3993 (i & 4) ? s->uvlinesize : s->linesize,
3994 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3996 block_cbp |= pat << (i << 2);
3997 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4002 if (s->mb_x == s->mb_width - 1)
4003 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4007 /** Decode one B-frame MB (in Main profile)
4009 static void vc1_decode_b_mb(VC1Context *v)
4011 MpegEncContext *s = &v->s;
4012 GetBitContext *gb = &s->gb;
4014 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4015 int cbp = 0; /* cbp decoding stuff */
4016 int mqdiff, mquant; /* MB quantization */
4017 int ttmb = v->ttfrm; /* MB Transform type */
4018 int mb_has_coeffs = 0; /* last_flag */
4019 int index, index1; /* LUT indexes */
4020 int val, sign; /* temp values */
4021 int first_block = 1;
4023 int skipped, direct;
4024 int dmv_x[2], dmv_y[2];
4025 int bmvtype = BMV_TYPE_BACKWARD;
4027 mquant = v->pq; /* lossy initialization */
4031 direct = get_bits1(gb);
4033 direct = v->direct_mb_plane[mb_pos];
4035 skipped = get_bits1(gb);
4037 skipped = v->s.mbskip_table[mb_pos];
4039 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4040 for (i = 0; i < 6; i++) {
4041 v->mb_type[0][s->block_index[i]] = 0;
4042 s->dc_val[0][s->block_index[i]] = 0;
4044 s->current_picture.f.qscale_table[mb_pos] = 0;
4048 GET_MVDATA(dmv_x[0], dmv_y[0]);
4049 dmv_x[1] = dmv_x[0];
4050 dmv_y[1] = dmv_y[0];
4052 if (skipped || !s->mb_intra) {
4053 bmvtype = decode012(gb);
4056 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4059 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4062 bmvtype = BMV_TYPE_INTERPOLATED;
4063 dmv_x[0] = dmv_y[0] = 0;
4067 for (i = 0; i < 6; i++)
4068 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4072 bmvtype = BMV_TYPE_INTERPOLATED;
4073 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4074 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4078 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4081 s->current_picture.f.qscale_table[mb_pos] = mquant;
4083 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4084 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4085 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4086 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4088 if (!mb_has_coeffs && !s->mb_intra) {
4089 /* no coded blocks - effectively skipped */
4090 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4091 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4094 if (s->mb_intra && !mb_has_coeffs) {
4096 s->current_picture.f.qscale_table[mb_pos] = mquant;
4097 s->ac_pred = get_bits1(gb);
4099 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4101 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4102 GET_MVDATA(dmv_x[0], dmv_y[0]);
4103 if (!mb_has_coeffs) {
4104 /* interpolated skipped block */
4105 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4106 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4110 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4112 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4115 s->ac_pred = get_bits1(gb);
4116 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4118 s->current_picture.f.qscale_table[mb_pos] = mquant;
4119 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4120 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4124 for (i = 0; i < 6; i++) {
4125 s->dc_val[0][s->block_index[i]] = 0;
4127 val = ((cbp >> (5 - i)) & 1);
4128 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4129 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4131 /* check if prediction blocks A and C are available */
4132 v->a_avail = v->c_avail = 0;
4133 if (i == 2 || i == 3 || !s->first_slice_line)
4134 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4135 if (i == 1 || i == 3 || s->mb_x)
4136 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4138 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4139 (i & 4) ? v->codingset2 : v->codingset);
4140 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4142 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4144 for (j = 0; j < 64; j++)
4145 s->block[i][j] <<= 1;
4146 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4148 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4149 first_block, s->dest[dst_idx] + off,
4150 (i & 4) ? s->uvlinesize : s->linesize,
4151 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4152 if (!v->ttmbf && ttmb < 8)
4159 /** Decode one B-frame MB (in interlaced field B picture)
4161 static void vc1_decode_b_mb_intfi(VC1Context *v)
4163 MpegEncContext *s = &v->s;
4164 GetBitContext *gb = &s->gb;
4166 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4167 int cbp = 0; /* cbp decoding stuff */
4168 int mqdiff, mquant; /* MB quantization */
4169 int ttmb = v->ttfrm; /* MB Transform type */
4170 int mb_has_coeffs = 0; /* last_flag */
4171 int val; /* temp value */
4172 int first_block = 1;
4175 int dmv_x[2], dmv_y[2], pred_flag[2];
4176 int bmvtype = BMV_TYPE_BACKWARD;
4177 int idx_mbmode, interpmvp;
4179 mquant = v->pq; /* Lossy initialization */
4182 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4183 if (idx_mbmode <= 1) { // intra MB
4184 s->mb_intra = v->is_intra[s->mb_x] = 1;
4185 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4186 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4187 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4189 s->current_picture.f.qscale_table[mb_pos] = mquant;
4190 /* Set DC scale - y and c use the same (not sure if necessary here) */
4191 s->y_dc_scale = s->y_dc_scale_table[mquant];
4192 s->c_dc_scale = s->c_dc_scale_table[mquant];
4193 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4194 mb_has_coeffs = idx_mbmode & 1;
4196 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4198 for (i = 0; i < 6; i++) {
4199 s->dc_val[0][s->block_index[i]] = 0;
4201 val = ((cbp >> (5 - i)) & 1);
4202 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4203 v->a_avail = v->c_avail = 0;
4204 if (i == 2 || i == 3 || !s->first_slice_line)
4205 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4206 if (i == 1 || i == 3 || s->mb_x)
4207 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4209 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4210 (i & 4) ? v->codingset2 : v->codingset);
4211 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4213 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4215 for (j = 0; j < 64; j++)
4216 s->block[i][j] <<= 1;
4217 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4218 off += v->second_field ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4219 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4220 // TODO: yet to perform loop filter
4223 s->mb_intra = v->is_intra[s->mb_x] = 0;
4224 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4225 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4227 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4229 fwd = v->forward_mb_plane[mb_pos];
4230 if (idx_mbmode <= 5) { // 1-MV
4231 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4232 pred_flag[0] = pred_flag[1] = 0;
4234 bmvtype = BMV_TYPE_FORWARD;
4236 bmvtype = decode012(gb);
4239 bmvtype = BMV_TYPE_BACKWARD;
4242 bmvtype = BMV_TYPE_DIRECT;
4245 bmvtype = BMV_TYPE_INTERPOLATED;
4246 interpmvp = get_bits1(gb);
4249 v->bmvtype = bmvtype;
4250 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4251 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4253 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4254 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4256 if (bmvtype == BMV_TYPE_DIRECT) {
4257 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4258 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4260 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4261 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4262 mb_has_coeffs = !(idx_mbmode & 2);
4265 bmvtype = BMV_TYPE_FORWARD;
4266 v->bmvtype = bmvtype;
4267 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4268 for (i = 0; i < 6; i++) {
4270 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4271 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4272 val = ((v->fourmvbp >> (3 - i)) & 1);
4274 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4275 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4276 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4278 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4279 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4281 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4283 mb_has_coeffs = idx_mbmode & 1;
4286 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4290 s->current_picture.f.qscale_table[mb_pos] = mquant;
4291 if (!v->ttmbf && cbp) {
4292 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4295 for (i = 0; i < 6; i++) {
4296 s->dc_val[0][s->block_index[i]] = 0;
4298 val = ((cbp >> (5 - i)) & 1);
4299 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4300 if (v->second_field)
4301 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4303 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4304 first_block, s->dest[dst_idx] + off,
4305 (i & 4) ? s->uvlinesize : s->linesize,
4306 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4307 if (!v->ttmbf && ttmb < 8)
4315 /** Decode blocks of I-frame
4317 static void vc1_decode_i_blocks(VC1Context *v)
4320 MpegEncContext *s = &v->s;
4325 /* select codingmode used for VLC tables selection */
4326 switch (v->y_ac_table_index) {
4328 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4331 v->codingset = CS_HIGH_MOT_INTRA;
4334 v->codingset = CS_MID_RATE_INTRA;
4338 switch (v->c_ac_table_index) {
4340 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4343 v->codingset2 = CS_HIGH_MOT_INTER;
4346 v->codingset2 = CS_MID_RATE_INTER;
4350 /* Set DC scale - y and c use the same */
4351 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4352 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4355 s->mb_x = s->mb_y = 0;
4357 s->first_slice_line = 1;
4358 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4360 ff_init_block_index(s);
4361 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4363 ff_update_block_index(s);
4364 dst[0] = s->dest[0];
4365 dst[1] = dst[0] + 8;
4366 dst[2] = s->dest[0] + s->linesize * 8;
4367 dst[3] = dst[2] + 8;
4368 dst[4] = s->dest[1];
4369 dst[5] = s->dest[2];
4370 s->dsp.clear_blocks(s->block[0]);
4371 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4372 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
4373 s->current_picture.f.qscale_table[mb_pos] = v->pq;
4374 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4375 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4377 // do actual MB decoding and displaying
4378 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4379 v->s.ac_pred = get_bits1(&v->s.gb);
4381 for (k = 0; k < 6; k++) {
4382 val = ((cbp >> (5 - k)) & 1);
4385 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4389 cbp |= val << (5 - k);
4391 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4393 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4395 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4396 if (v->pq >= 9 && v->overlap) {
4398 for (j = 0; j < 64; j++)
4399 s->block[k][j] <<= 1;
4400 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4403 for (j = 0; j < 64; j++)
4404 s->block[k][j] = (s->block[k][j] - 64) << 1;
4405 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4409 if (v->pq >= 9 && v->overlap) {
4411 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4412 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4413 if (!(s->flags & CODEC_FLAG_GRAY)) {
4414 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4415 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4418 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4419 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4420 if (!s->first_slice_line) {
4421 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4422 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4423 if (!(s->flags & CODEC_FLAG_GRAY)) {
4424 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4425 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4428 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4429 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4431 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4433 if (get_bits_count(&s->gb) > v->bits) {
4434 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4435 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4436 get_bits_count(&s->gb), v->bits);
4440 if (!v->s.loop_filter)
4441 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4443 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4445 s->first_slice_line = 0;
4447 if (v->s.loop_filter)
4448 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4450 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4451 * profile, these only differ are when decoding MSS2 rectangles. */
4452 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4455 /** Decode blocks of I-frame for advanced profile
4457 static void vc1_decode_i_blocks_adv(VC1Context *v)
4460 MpegEncContext *s = &v->s;
4466 GetBitContext *gb = &s->gb;
4468 /* select codingmode used for VLC tables selection */
4469 switch (v->y_ac_table_index) {
4471 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4474 v->codingset = CS_HIGH_MOT_INTRA;
4477 v->codingset = CS_MID_RATE_INTRA;
4481 switch (v->c_ac_table_index) {
4483 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4486 v->codingset2 = CS_HIGH_MOT_INTER;
4489 v->codingset2 = CS_MID_RATE_INTER;
4494 s->mb_x = s->mb_y = 0;
4496 s->first_slice_line = 1;
4497 s->mb_y = s->start_mb_y;
4498 if (s->start_mb_y) {
4500 ff_init_block_index(s);
4501 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4502 (1 + s->b8_stride) * sizeof(*s->coded_block));
4504 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4506 ff_init_block_index(s);
4507 for (;s->mb_x < s->mb_width; s->mb_x++) {
4508 DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
4509 ff_update_block_index(s);
4510 s->dsp.clear_blocks(block[0]);
4511 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4512 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4513 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4514 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4516 // do actual MB decoding and displaying
4517 if (v->fieldtx_is_raw)
4518 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4519 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4520 if ( v->acpred_is_raw)
4521 v->s.ac_pred = get_bits1(&v->s.gb);
4523 v->s.ac_pred = v->acpred_plane[mb_pos];
4525 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4526 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4530 s->current_picture.f.qscale_table[mb_pos] = mquant;
4531 /* Set DC scale - y and c use the same */
4532 s->y_dc_scale = s->y_dc_scale_table[mquant];
4533 s->c_dc_scale = s->c_dc_scale_table[mquant];
4535 for (k = 0; k < 6; k++) {
4536 val = ((cbp >> (5 - k)) & 1);
4539 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4543 cbp |= val << (5 - k);
4545 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4546 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4548 vc1_decode_i_block_adv(v, block[k], k, val,
4549 (k < 4) ? v->codingset : v->codingset2, mquant);
4551 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4553 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4556 vc1_smooth_overlap_filter_iblk(v);
4557 vc1_put_signed_blocks_clamped(v);
4558 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4560 if (get_bits_count(&s->gb) > v->bits) {
4561 // TODO: may need modification to handle slice coding
4562 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4563 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4564 get_bits_count(&s->gb), v->bits);
4568 if (!v->s.loop_filter)
4569 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4571 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4572 s->first_slice_line = 0;
4575 /* raw bottom MB row */
4577 ff_init_block_index(s);
4578 for (;s->mb_x < s->mb_width; s->mb_x++) {
4579 ff_update_block_index(s);
4580 vc1_put_signed_blocks_clamped(v);
4581 if (v->s.loop_filter)
4582 vc1_loop_filter_iblk_delayed(v, v->pq);
4584 if (v->s.loop_filter)
4585 ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4586 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4587 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4590 static void vc1_decode_p_blocks(VC1Context *v)
4592 MpegEncContext *s = &v->s;
4593 int apply_loop_filter;
4595 /* select codingmode used for VLC tables selection */
4596 switch (v->c_ac_table_index) {
4598 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4601 v->codingset = CS_HIGH_MOT_INTRA;
4604 v->codingset = CS_MID_RATE_INTRA;
4608 switch (v->c_ac_table_index) {
4610 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4613 v->codingset2 = CS_HIGH_MOT_INTER;
4616 v->codingset2 = CS_MID_RATE_INTER;
4620 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
4621 s->first_slice_line = 1;
4622 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
4623 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4625 ff_init_block_index(s);
4626 for (; s->mb_x < s->mb_width; s->mb_x++) {
4627 ff_update_block_index(s);
4629 if (v->fcm == ILACE_FIELD)
4630 vc1_decode_p_mb_intfi(v);
4631 else if (v->fcm == ILACE_FRAME)
4632 vc1_decode_p_mb_intfr(v);
4633 else vc1_decode_p_mb(v);
4634 if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == PROGRESSIVE)
4635 vc1_apply_p_loop_filter(v);
4636 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4637 // TODO: may need modification to handle slice coding
4638 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4639 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4640 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4644 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
4645 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
4646 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4647 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
4648 if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4649 s->first_slice_line = 0;
4651 if (apply_loop_filter && v->fcm == PROGRESSIVE) {
4653 ff_init_block_index(s);
4654 for (; s->mb_x < s->mb_width; s->mb_x++) {
4655 ff_update_block_index(s);
4656 vc1_apply_p_loop_filter(v);
4659 if (s->end_mb_y >= s->start_mb_y)
4660 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4661 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4662 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4665 static void vc1_decode_b_blocks(VC1Context *v)
4667 MpegEncContext *s = &v->s;
4669 /* select codingmode used for VLC tables selection */
4670 switch (v->c_ac_table_index) {
4672 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4675 v->codingset = CS_HIGH_MOT_INTRA;
4678 v->codingset = CS_MID_RATE_INTRA;
4682 switch (v->c_ac_table_index) {
4684 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4687 v->codingset2 = CS_HIGH_MOT_INTER;
4690 v->codingset2 = CS_MID_RATE_INTER;
4694 s->first_slice_line = 1;
4695 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4697 ff_init_block_index(s);
4698 for (; s->mb_x < s->mb_width; s->mb_x++) {
4699 ff_update_block_index(s);
4701 if (v->fcm == ILACE_FIELD)
4702 vc1_decode_b_mb_intfi(v);
4705 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4706 // TODO: may need modification to handle slice coding
4707 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4708 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4709 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4712 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4714 if (!v->s.loop_filter)
4715 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4717 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4718 s->first_slice_line = 0;
4720 if (v->s.loop_filter)
4721 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4722 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4723 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4726 static void vc1_decode_skip_blocks(VC1Context *v)
4728 MpegEncContext *s = &v->s;
4730 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
4731 s->first_slice_line = 1;
4732 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4734 ff_init_block_index(s);
4735 ff_update_block_index(s);
4736 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4737 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4738 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4739 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4740 s->first_slice_line = 0;
4742 s->pict_type = AV_PICTURE_TYPE_P;
4745 void ff_vc1_decode_blocks(VC1Context *v)
4748 v->s.esc3_level_length = 0;
4750 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
4753 v->left_blk_idx = -1;
4754 v->topleft_blk_idx = 1;
4756 switch (v->s.pict_type) {
4757 case AV_PICTURE_TYPE_I:
4758 if (v->profile == PROFILE_ADVANCED)
4759 vc1_decode_i_blocks_adv(v);
4761 vc1_decode_i_blocks(v);
4763 case AV_PICTURE_TYPE_P:
4764 if (v->p_frame_skipped)
4765 vc1_decode_skip_blocks(v);
4767 vc1_decode_p_blocks(v);
4769 case AV_PICTURE_TYPE_B:
4771 if (v->profile == PROFILE_ADVANCED)
4772 vc1_decode_i_blocks_adv(v);
4774 vc1_decode_i_blocks(v);
4776 vc1_decode_b_blocks(v);
4782 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
4786 * Transform coefficients for both sprites in 16.16 fixed point format,
4787 * in the order they appear in the bitstream:
4789 * rotation 1 (unused)
4791 * rotation 2 (unused)
4798 int effect_type, effect_flag;
4799 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
4800 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
4803 static inline int get_fp_val(GetBitContext* gb)
4805 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
4808 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
4812 switch (get_bits(gb, 2)) {
4815 c[2] = get_fp_val(gb);
4819 c[0] = c[4] = get_fp_val(gb);
4820 c[2] = get_fp_val(gb);
4823 c[0] = get_fp_val(gb);
4824 c[2] = get_fp_val(gb);
4825 c[4] = get_fp_val(gb);
4828 c[0] = get_fp_val(gb);
4829 c[1] = get_fp_val(gb);
4830 c[2] = get_fp_val(gb);
4831 c[3] = get_fp_val(gb);
4832 c[4] = get_fp_val(gb);
4835 c[5] = get_fp_val(gb);
4837 c[6] = get_fp_val(gb);
4842 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
4844 AVCodecContext *avctx = v->s.avctx;
4847 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4848 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
4849 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
4850 av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
4851 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
4852 for (i = 0; i < 7; i++)
4853 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
4854 sd->coefs[sprite][i] / (1<<16),
4855 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
4856 av_log(avctx, AV_LOG_DEBUG, "\n");
4860 if (sd->effect_type = get_bits_long(gb, 30)) {
4861 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
4863 vc1_sprite_parse_transform(gb, sd->effect_params1);
4866 vc1_sprite_parse_transform(gb, sd->effect_params1);
4867 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
4870 for (i = 0; i < sd->effect_pcount1; i++)
4871 sd->effect_params1[i] = get_fp_val(gb);
4873 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
4874 // effect 13 is simple alpha blending and matches the opacity above
4875 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
4876 for (i = 0; i < sd->effect_pcount1; i++)
4877 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4878 sd->effect_params1[i] / (1 << 16),
4879 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
4880 av_log(avctx, AV_LOG_DEBUG, "\n");
4883 sd->effect_pcount2 = get_bits(gb, 16);
4884 if (sd->effect_pcount2 > 10) {
4885 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
4887 } else if (sd->effect_pcount2) {
4889 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
4890 while (++i < sd->effect_pcount2) {
4891 sd->effect_params2[i] = get_fp_val(gb);
4892 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4893 sd->effect_params2[i] / (1 << 16),
4894 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
4896 av_log(avctx, AV_LOG_DEBUG, "\n");
4899 if (sd->effect_flag = get_bits1(gb))
4900 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4902 if (get_bits_count(gb) >= gb->size_in_bits +
4903 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
4904 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4905 if (get_bits_count(gb) < gb->size_in_bits - 8)
4906 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4909 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
4911 int i, plane, row, sprite;
4912 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
4913 uint8_t* src_h[2][2];
4914 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
4916 MpegEncContext *s = &v->s;
4918 for (i = 0; i < 2; i++) {
4919 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
4920 xadv[i] = sd->coefs[i][0];
4921 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
4922 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
4924 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
4925 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
4927 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
4929 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
4930 int width = v->output_width>>!!plane;
4932 for (row = 0; row < v->output_height>>!!plane; row++) {
4933 uint8_t *dst = v->sprite_output_frame.data[plane] +
4934 v->sprite_output_frame.linesize[plane] * row;
4936 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4937 uint8_t *iplane = s->current_picture.f.data[plane];
4938 int iline = s->current_picture.f.linesize[plane];
4939 int ycoord = yoff[sprite] + yadv[sprite] * row;
4940 int yline = ycoord >> 16;
4942 ysub[sprite] = ycoord & 0xFFFF;
4944 iplane = s->last_picture.f.data[plane];
4945 iline = s->last_picture.f.linesize[plane];
4947 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
4948 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4949 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
4951 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
4953 if (sr_cache[sprite][0] != yline) {
4954 if (sr_cache[sprite][1] == yline) {
4955 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
4956 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
4958 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
4959 sr_cache[sprite][0] = yline;
4962 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4963 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
4964 iplane + next_line, xoff[sprite],
4965 xadv[sprite], width);
4966 sr_cache[sprite][1] = yline + 1;
4968 src_h[sprite][0] = v->sr_rows[sprite][0];
4969 src_h[sprite][1] = v->sr_rows[sprite][1];
4973 if (!v->two_sprites) {
4975 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
4977 memcpy(dst, src_h[0][0], width);
4980 if (ysub[0] && ysub[1]) {
4981 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
4982 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
4983 } else if (ysub[0]) {
4984 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
4985 src_h[1][0], alpha, width);
4986 } else if (ysub[1]) {
4987 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
4988 src_h[0][0], (1<<16)-1-alpha, width);
4990 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
4996 for (i = 0; i < 2; i++) {
5006 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5008 MpegEncContext *s = &v->s;
5009 AVCodecContext *avctx = s->avctx;
5012 vc1_parse_sprites(v, gb, &sd);
5014 if (!s->current_picture.f.data[0]) {
5015 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5019 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5020 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5024 if (v->sprite_output_frame.data[0])
5025 avctx->release_buffer(avctx, &v->sprite_output_frame);
5027 v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5028 v->sprite_output_frame.reference = 0;
5029 if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
5030 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5034 vc1_draw_sprites(v, &sd);
5039 static void vc1_sprite_flush(AVCodecContext *avctx)
5041 VC1Context *v = avctx->priv_data;
5042 MpegEncContext *s = &v->s;
5043 AVFrame *f = &s->current_picture.f;
5046 /* Windows Media Image codecs have a convergence interval of two keyframes.
5047 Since we can't enforce it, clear to black the missing sprite. This is
5048 wrong but it looks better than doing nothing. */
5051 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5052 for (i = 0; i < v->sprite_height>>!!plane; i++)
5053 memset(f->data[plane] + i * f->linesize[plane],
5054 plane ? 128 : 0, f->linesize[plane]);
5059 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5061 MpegEncContext *s = &v->s;
5064 /* Allocate mb bitplanes */
5065 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5066 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5067 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5068 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5069 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5070 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5072 v->n_allocated_blks = s->mb_width + 2;
5073 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5074 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5075 v->cbp = v->cbp_base + s->mb_stride;
5076 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5077 v->ttblk = v->ttblk_base + s->mb_stride;
5078 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5079 v->is_intra = v->is_intra_base + s->mb_stride;
5080 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5081 v->luma_mv = v->luma_mv_base + s->mb_stride;
5083 /* allocate block type info in that way so it could be used with s->block_index[] */
5084 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5085 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5086 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5087 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5089 /* allocate memory to store block level MV info */
5090 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5091 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5092 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5093 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5094 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5095 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5096 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
5097 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);
5098 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5099 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5100 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);
5102 /* Init coded blocks info */
5103 if (v->profile == PROFILE_ADVANCED) {
5104 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5106 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5110 ff_intrax8_common_init(&v->x8,s);
5112 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5113 for (i = 0; i < 4; i++)
5114 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5117 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5118 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5125 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5128 for (i = 0; i < 64; i++) {
5129 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5130 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5131 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5132 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5133 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5134 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5140 /** Initialize a VC1/WMV3 decoder
5141 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5142 * @todo TODO: Decypher remaining bits in extra_data
5144 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5146 VC1Context *v = avctx->priv_data;
5147 MpegEncContext *s = &v->s;
5150 /* save the container output size for WMImage */
5151 v->output_width = avctx->width;
5152 v->output_height = avctx->height;
5154 if (!avctx->extradata_size || !avctx->extradata)
5156 if (!(avctx->flags & CODEC_FLAG_GRAY))
5157 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5159 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5160 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5162 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5163 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5165 if (avctx->idct_algo == FF_IDCT_AUTO) {
5166 avctx->idct_algo = FF_IDCT_WMV2;
5169 if (ff_vc1_init_common(v) < 0)
5171 ff_vc1dsp_init(&v->vc1dsp);
5173 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5176 // looks like WMV3 has a sequence header stored in the extradata
5177 // advanced sequence header may be before the first frame
5178 // the last byte of the extradata is a version number, 1 for the
5179 // samples we can decode
5181 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5183 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5186 count = avctx->extradata_size*8 - get_bits_count(&gb);
5188 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5189 count, get_bits(&gb, count));
5190 } else if (count < 0) {
5191 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5193 } else { // VC1/WVC1/WVP2
5194 const uint8_t *start = avctx->extradata;
5195 uint8_t *end = avctx->extradata + avctx->extradata_size;
5196 const uint8_t *next;
5197 int size, buf2_size;
5198 uint8_t *buf2 = NULL;
5199 int seq_initialized = 0, ep_initialized = 0;
5201 if (avctx->extradata_size < 16) {
5202 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5206 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5207 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5209 for (; next < end; start = next) {
5210 next = find_next_marker(start + 4, end);
5211 size = next - start - 4;
5214 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5215 init_get_bits(&gb, buf2, buf2_size * 8);
5216 switch (AV_RB32(start)) {
5217 case VC1_CODE_SEQHDR:
5218 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5222 seq_initialized = 1;
5224 case VC1_CODE_ENTRYPOINT:
5225 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5234 if (!seq_initialized || !ep_initialized) {
5235 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5238 v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
5241 avctx->profile = v->profile;
5242 if (v->profile == PROFILE_ADVANCED)
5243 avctx->level = v->level;
5245 avctx->has_b_frames = !!avctx->max_b_frames;
5247 s->mb_width = (avctx->coded_width + 15) >> 4;
5248 s->mb_height = (avctx->coded_height + 15) >> 4;
5250 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5251 ff_vc1_init_transposed_scantables(v);
5253 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5258 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5259 v->sprite_width = avctx->coded_width;
5260 v->sprite_height = avctx->coded_height;
5262 avctx->coded_width = avctx->width = v->output_width;
5263 avctx->coded_height = avctx->height = v->output_height;
5265 // prevent 16.16 overflows
5266 if (v->sprite_width > 1 << 14 ||
5267 v->sprite_height > 1 << 14 ||
5268 v->output_width > 1 << 14 ||
5269 v->output_height > 1 << 14) return -1;
5274 /** Close a VC1/WMV3 decoder
5275 * @warning Initial try at using MpegEncContext stuff
5277 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5279 VC1Context *v = avctx->priv_data;
5282 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5283 && v->sprite_output_frame.data[0])
5284 avctx->release_buffer(avctx, &v->sprite_output_frame);
5285 for (i = 0; i < 4; i++)
5286 av_freep(&v->sr_rows[i >> 1][i & 1]);
5287 av_freep(&v->hrd_rate);
5288 av_freep(&v->hrd_buffer);
5289 ff_MPV_common_end(&v->s);
5290 av_freep(&v->mv_type_mb_plane);
5291 av_freep(&v->direct_mb_plane);
5292 av_freep(&v->forward_mb_plane);
5293 av_freep(&v->fieldtx_plane);
5294 av_freep(&v->acpred_plane);
5295 av_freep(&v->over_flags_plane);
5296 av_freep(&v->mb_type_base);
5297 av_freep(&v->blk_mv_type_base);
5298 av_freep(&v->mv_f_base);
5299 av_freep(&v->mv_f_last_base);
5300 av_freep(&v->mv_f_next_base);
5301 av_freep(&v->block);
5302 av_freep(&v->cbp_base);
5303 av_freep(&v->ttblk_base);
5304 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5305 av_freep(&v->luma_mv_base);
5306 ff_intrax8_common_end(&v->x8);
5311 /** Decode a VC1/WMV3 frame
5312 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5314 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5315 int *data_size, AVPacket *avpkt)
5317 const uint8_t *buf = avpkt->data;
5318 int buf_size = avpkt->size, n_slices = 0, i;
5319 VC1Context *v = avctx->priv_data;
5320 MpegEncContext *s = &v->s;
5321 AVFrame *pict = data;
5322 uint8_t *buf2 = NULL;
5323 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
5324 int mb_height, n_slices1=-1;
5329 } *slices = NULL, *tmp;
5331 v->second_field = 0;
5333 if(s->flags & CODEC_FLAG_LOW_DELAY)
5336 /* no supplementary picture */
5337 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5338 /* special case for last picture */
5339 if (s->low_delay == 0 && s->next_picture_ptr) {
5340 *pict = s->next_picture_ptr->f;
5341 s->next_picture_ptr = NULL;
5343 *data_size = sizeof(AVFrame);
5349 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5350 if (v->profile < PROFILE_ADVANCED)
5351 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5353 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5356 //for advanced profile we may need to parse and unescape data
5357 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5359 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5361 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5362 const uint8_t *start, *end, *next;
5366 for (start = buf, end = buf + buf_size; next < end; start = next) {
5367 next = find_next_marker(start + 4, end);
5368 size = next - start - 4;
5369 if (size <= 0) continue;
5370 switch (AV_RB32(start)) {
5371 case VC1_CODE_FRAME:
5372 if (avctx->hwaccel ||
5373 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5375 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5377 case VC1_CODE_FIELD: {
5379 if (avctx->hwaccel ||
5380 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5381 buf_start_second_field = start;
5382 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5386 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5387 if (!slices[n_slices].buf)
5389 buf_size3 = vc1_unescape_buffer(start + 4, size,
5390 slices[n_slices].buf);
5391 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5393 /* assuming that the field marker is at the exact middle,
5394 hope it's correct */
5395 slices[n_slices].mby_start = s->mb_height >> 1;
5396 n_slices1 = n_slices - 1; // index of the last slice of the first field
5400 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5401 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5402 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5403 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5405 case VC1_CODE_SLICE: {
5407 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5411 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5412 if (!slices[n_slices].buf)
5414 buf_size3 = vc1_unescape_buffer(start + 4, size,
5415 slices[n_slices].buf);
5416 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5418 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5424 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5425 const uint8_t *divider;
5428 divider = find_next_marker(buf, buf + buf_size);
5429 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5430 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5432 } else { // found field marker, unescape second field
5433 if (avctx->hwaccel ||
5434 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5435 buf_start_second_field = divider;
5436 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5440 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5441 if (!slices[n_slices].buf)
5443 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5444 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5446 slices[n_slices].mby_start = s->mb_height >> 1;
5447 n_slices1 = n_slices - 1;
5450 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5452 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5454 init_get_bits(&s->gb, buf2, buf_size2*8);
5456 init_get_bits(&s->gb, buf, buf_size*8);
5458 if (v->res_sprite) {
5459 v->new_sprite = !get_bits1(&s->gb);
5460 v->two_sprites = get_bits1(&s->gb);
5461 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5462 we're using the sprite compositor. These are intentionally kept separate
5463 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5464 the vc1 one for WVP2 */
5465 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5466 if (v->new_sprite) {
5467 // switch AVCodecContext parameters to those of the sprites
5468 avctx->width = avctx->coded_width = v->sprite_width;
5469 avctx->height = avctx->coded_height = v->sprite_height;
5476 if (s->context_initialized &&
5477 (s->width != avctx->coded_width ||
5478 s->height != avctx->coded_height)) {
5479 ff_vc1_decode_end(avctx);
5482 if (!s->context_initialized) {
5483 if (ff_msmpeg4_decode_init(avctx) < 0 || ff_vc1_decode_init_alloc_tables(v) < 0)
5486 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5488 if (v->profile == PROFILE_ADVANCED) {
5489 s->h_edge_pos = avctx->coded_width;
5490 s->v_edge_pos = avctx->coded_height;
5494 /* We need to set current_picture_ptr before reading the header,
5495 * otherwise we cannot store anything in there. */
5496 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5497 int i = ff_find_unused_picture(s, 0);
5500 s->current_picture_ptr = &s->picture[i];
5503 // do parse frame header
5504 v->pic_header_flag = 0;
5505 if (v->profile < PROFILE_ADVANCED) {
5506 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5510 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5515 if (avctx->debug & FF_DEBUG_PICT_INFO)
5516 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
5518 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5519 && s->pict_type != AV_PICTURE_TYPE_I) {
5520 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5524 // process pulldown flags
5525 s->current_picture_ptr->f.repeat_pict = 0;
5526 // Pulldown flags are only valid when 'broadcast' has been set.
5527 // So ticks_per_frame will be 2
5530 s->current_picture_ptr->f.repeat_pict = 1;
5531 } else if (v->rptfrm) {
5533 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5536 // for skipping the frame
5537 s->current_picture.f.pict_type = s->pict_type;
5538 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5540 /* skip B-frames if we don't have reference frames */
5541 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
5544 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5545 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5546 avctx->skip_frame >= AVDISCARD_ALL) {
5550 if (s->next_p_frame_damaged) {
5551 if (s->pict_type == AV_PICTURE_TYPE_B)
5554 s->next_p_frame_damaged = 0;
5557 if (ff_MPV_frame_start(s, avctx) < 0) {
5561 v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
5562 v->s.current_picture_ptr->f.top_field_first = v->tff;
5564 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5565 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5567 if ((CONFIG_VC1_VDPAU_DECODER)
5568 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5569 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5570 else if (avctx->hwaccel) {
5571 if (v->field_mode && buf_start_second_field) {
5572 // decode first field
5573 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
5574 if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
5576 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
5578 if (avctx->hwaccel->end_frame(avctx) < 0)
5581 // decode second field
5582 s->gb = slices[n_slices1 + 1].gb;
5583 s->picture_structure = PICT_TOP_FIELD + v->tff;
5584 v->second_field = 1;
5585 v->pic_header_flag = 0;
5586 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5587 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
5590 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
5592 if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
5594 if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
5596 if (avctx->hwaccel->end_frame(avctx) < 0)
5599 s->picture_structure = PICT_FRAME;
5600 if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5602 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5604 if (avctx->hwaccel->end_frame(avctx) < 0)
5608 if (v->fcm == ILACE_FRAME && s->pict_type == AV_PICTURE_TYPE_B)
5609 goto err; // This codepath is still incomplete thus it is disabled
5611 ff_er_frame_start(s);
5613 v->bits = buf_size * 8;
5614 v->end_mb_x = s->mb_width;
5615 if (v->field_mode) {
5617 s->current_picture.f.linesize[0] <<= 1;
5618 s->current_picture.f.linesize[1] <<= 1;
5619 s->current_picture.f.linesize[2] <<= 1;
5621 s->uvlinesize <<= 1;
5622 tmp[0] = v->mv_f_last[0];
5623 tmp[1] = v->mv_f_last[1];
5624 v->mv_f_last[0] = v->mv_f_next[0];
5625 v->mv_f_last[1] = v->mv_f_next[1];
5626 v->mv_f_next[0] = v->mv_f[0];
5627 v->mv_f_next[1] = v->mv_f[1];
5628 v->mv_f[0] = tmp[0];
5629 v->mv_f[1] = tmp[1];
5631 mb_height = s->mb_height >> v->field_mode;
5632 for (i = 0; i <= n_slices; i++) {
5633 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5634 if (v->field_mode <= 0) {
5635 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
5636 "picture boundary (%d >= %d)\n", i,
5637 slices[i - 1].mby_start, mb_height);
5640 v->second_field = 1;
5641 v->blocks_off = s->mb_width * s->mb_height << 1;
5642 v->mb_off = s->mb_stride * s->mb_height >> 1;
5644 v->second_field = 0;
5649 v->pic_header_flag = 0;
5650 if (v->field_mode && i == n_slices1 + 2) {
5651 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5652 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
5655 } else if (get_bits1(&s->gb)) {
5656 v->pic_header_flag = 1;
5657 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5658 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
5663 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5664 if (!v->field_mode || v->second_field)
5665 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5667 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5668 if (s->end_mb_y <= s->start_mb_y) {
5669 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
5672 ff_vc1_decode_blocks(v);
5674 s->gb = slices[i].gb;
5676 if (v->field_mode) {
5677 v->second_field = 0;
5678 if (s->pict_type == AV_PICTURE_TYPE_B) {
5679 memcpy(v->mv_f_base, v->mv_f_next_base,
5680 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5682 s->current_picture.f.linesize[0] >>= 1;
5683 s->current_picture.f.linesize[1] >>= 1;
5684 s->current_picture.f.linesize[2] >>= 1;
5686 s->uvlinesize >>= 1;
5688 av_dlog(s->avctx, "Consumed %i/%i bits\n",
5689 get_bits_count(&s->gb), s->gb.size_in_bits);
5690 // if (get_bits_count(&s->gb) > buf_size * 8)
5692 if(s->error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
5698 ff_MPV_frame_end(s);
5700 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5702 avctx->width = avctx->coded_width = v->output_width;
5703 avctx->height = avctx->coded_height = v->output_height;
5704 if (avctx->skip_frame >= AVDISCARD_NONREF)
5706 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5707 if (vc1_decode_sprites(v, &s->gb))
5710 *pict = v->sprite_output_frame;
5711 *data_size = sizeof(AVFrame);
5713 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5714 *pict = s->current_picture_ptr->f;
5715 } else if (s->last_picture_ptr != NULL) {
5716 *pict = s->last_picture_ptr->f;
5718 if (s->last_picture_ptr || s->low_delay) {
5719 *data_size = sizeof(AVFrame);
5720 ff_print_debug_info(s, pict);
5726 for (i = 0; i < n_slices; i++)
5727 av_free(slices[i].buf);
5733 for (i = 0; i < n_slices; i++)
5734 av_free(slices[i].buf);
5740 static const AVProfile profiles[] = {
5741 { FF_PROFILE_VC1_SIMPLE, "Simple" },
5742 { FF_PROFILE_VC1_MAIN, "Main" },
5743 { FF_PROFILE_VC1_COMPLEX, "Complex" },
5744 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5745 { FF_PROFILE_UNKNOWN },
5748 AVCodec ff_vc1_decoder = {
5750 .type = AVMEDIA_TYPE_VIDEO,
5751 .id = AV_CODEC_ID_VC1,
5752 .priv_data_size = sizeof(VC1Context),
5753 .init = vc1_decode_init,
5754 .close = ff_vc1_decode_end,
5755 .decode = vc1_decode_frame,
5756 .flush = ff_mpeg_flush,
5757 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5758 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5759 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5760 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5763 #if CONFIG_WMV3_DECODER
5764 AVCodec ff_wmv3_decoder = {
5766 .type = AVMEDIA_TYPE_VIDEO,
5767 .id = AV_CODEC_ID_WMV3,
5768 .priv_data_size = sizeof(VC1Context),
5769 .init = vc1_decode_init,
5770 .close = ff_vc1_decode_end,
5771 .decode = vc1_decode_frame,
5772 .flush = ff_mpeg_flush,
5773 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5774 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5775 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5776 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5780 #if CONFIG_WMV3_VDPAU_DECODER
5781 AVCodec ff_wmv3_vdpau_decoder = {
5782 .name = "wmv3_vdpau",
5783 .type = AVMEDIA_TYPE_VIDEO,
5784 .id = AV_CODEC_ID_WMV3,
5785 .priv_data_size = sizeof(VC1Context),
5786 .init = vc1_decode_init,
5787 .close = ff_vc1_decode_end,
5788 .decode = vc1_decode_frame,
5789 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5790 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5791 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
5792 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5796 #if CONFIG_VC1_VDPAU_DECODER
5797 AVCodec ff_vc1_vdpau_decoder = {
5798 .name = "vc1_vdpau",
5799 .type = AVMEDIA_TYPE_VIDEO,
5800 .id = AV_CODEC_ID_VC1,
5801 .priv_data_size = sizeof(VC1Context),
5802 .init = vc1_decode_init,
5803 .close = ff_vc1_decode_end,
5804 .decode = vc1_decode_frame,
5805 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5806 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5807 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
5808 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5812 #if CONFIG_WMV3IMAGE_DECODER
5813 AVCodec ff_wmv3image_decoder = {
5814 .name = "wmv3image",
5815 .type = AVMEDIA_TYPE_VIDEO,
5816 .id = AV_CODEC_ID_WMV3IMAGE,
5817 .priv_data_size = sizeof(VC1Context),
5818 .init = vc1_decode_init,
5819 .close = ff_vc1_decode_end,
5820 .decode = vc1_decode_frame,
5821 .capabilities = CODEC_CAP_DR1,
5822 .flush = vc1_sprite_flush,
5823 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5824 .pix_fmts = ff_pixfmt_list_420
5828 #if CONFIG_VC1IMAGE_DECODER
5829 AVCodec ff_vc1image_decoder = {
5831 .type = AVMEDIA_TYPE_VIDEO,
5832 .id = AV_CODEC_ID_VC1IMAGE,
5833 .priv_data_size = sizeof(VC1Context),
5834 .init = vc1_decode_init,
5835 .close = ff_vc1_decode_end,
5836 .decode = vc1_decode_frame,
5837 .capabilities = CODEC_CAP_DR1,
5838 .flush = vc1_sprite_flush,
5839 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5840 .pix_fmts = ff_pixfmt_list_420