2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of Libav.
9 * Libav is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * Libav is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with Libav; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
32 #include "mpegvideo.h"
36 #include "vc1acdata.h"
37 #include "msmpeg4data.h"
39 #include "simple_idct.h"
41 #include "vdpau_internal.h"
46 #define MB_INTRA_VLC_BITS 9
50 // offset tables for interlaced picture MVDATA decoding
51 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
52 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
54 /***********************************************************************/
56 * @name VC-1 Bitplane decoding
74 /** @} */ //imode defines
77 /** @} */ //Bitplane group
79 static void vc1_put_signed_blocks_clamped(VC1Context *v)
81 MpegEncContext *s = &v->s;
82 int topleft_mb_pos, top_mb_pos;
83 int stride_y, fieldtx;
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->cur_field_type) {
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 - s->mspel) > v_edge_pos - (my&3) - 16 - s->mspel * 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->cur_field_type) {
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->cur_field_type)
565 srcY = s->current_picture.f.data[0];
567 srcY = s->last_picture.f.data[0];
569 srcY = s->last_picture.f.data[0];
571 srcY = s->next_picture.f.data[0];
574 if (v->cur_field_type != v->ref_field_type[dir])
575 my = my - 2 + 4 * v->cur_field_type;
578 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
579 int same_count = 0, opp_count = 0, k;
580 int chosen_mv[2][4][2], f;
582 for (k = 0; k < 4; k++) {
583 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
584 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
585 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
589 f = opp_count > same_count;
590 switch (f ? opp_count : same_count) {
592 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
593 chosen_mv[f][2][0], chosen_mv[f][3][0]);
594 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
595 chosen_mv[f][2][1], chosen_mv[f][3][1]);
598 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
599 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
602 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
603 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
606 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
607 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
608 for (k = 0; k < 4; k++)
609 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
612 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
614 int width = s->avctx->coded_width;
615 int height = s->avctx->coded_height >> 1;
616 qx = (s->mb_x * 16) + (mx >> 2);
617 qy = (s->mb_y * 8) + (my >> 3);
622 mx -= 4 * (qx - width);
625 else if (qy > height + 1)
626 my -= 8 * (qy - height - 1);
629 if ((v->fcm == ILACE_FRAME) && fieldmv)
630 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
632 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
633 if (v->field_mode && v->cur_field_type)
634 off += s->current_picture_ptr->f.linesize[0];
636 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
638 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
640 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
642 if (v->profile != PROFILE_ADVANCED) {
643 src_x = av_clip(src_x, -16, s->mb_width * 16);
644 src_y = av_clip(src_y, -16, s->mb_height * 16);
646 src_x = av_clip(src_x, -17, s->avctx->coded_width);
647 if (v->fcm == ILACE_FRAME) {
649 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
651 src_y = av_clip(src_y, -18, s->avctx->coded_height);
653 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
657 srcY += src_y * s->linesize + src_x;
658 if (v->field_mode && v->ref_field_type[dir])
659 srcY += s->current_picture_ptr->f.linesize[0];
661 if (fieldmv && !(src_y & 1))
663 if (fieldmv && (src_y & 1) && src_y < 4)
665 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
666 || s->h_edge_pos < 13 || v_edge_pos < 23
667 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
668 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
669 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
670 /* check emulate edge stride and offset */
671 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
672 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
673 src_x - s->mspel, src_y - (s->mspel << fieldmv),
674 s->h_edge_pos, v_edge_pos);
675 srcY = s->edge_emu_buffer;
676 /* if we deal with range reduction we need to scale source blocks */
677 if (v->rangeredfrm) {
682 for (j = 0; j < 9 + s->mspel * 2; j++) {
683 for (i = 0; i < 9 + s->mspel * 2; i++)
684 src[i] = ((src[i] - 128) >> 1) + 128;
685 src += s->linesize << fieldmv;
688 /* if we deal with intensity compensation we need to scale source blocks */
689 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
694 for (j = 0; j < 9 + s->mspel * 2; j++) {
695 for (i = 0; i < 9 + s->mspel * 2; i++)
696 src[i] = v->luty[src[i]];
697 src += s->linesize << fieldmv;
700 srcY += s->mspel * (1 + (s->linesize << fieldmv));
704 dxy = ((my & 3) << 2) | (mx & 3);
705 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
706 } else { // hpel mc - always used for luma
707 dxy = (my & 2) | ((mx & 2) >> 1);
709 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
711 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
715 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
718 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
720 idx = ((a[3] != flag) << 3)
721 | ((a[2] != flag) << 2)
722 | ((a[1] != flag) << 1)
725 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
726 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
728 } else if (count[idx] == 1) {
731 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
732 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
735 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
736 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
739 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
740 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
743 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
744 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
747 } else if (count[idx] == 2) {
749 for (i = 0; i < 3; i++)
754 for (i = t1 + 1; i < 4; i++)
759 *tx = (mvx[t1] + mvx[t2]) / 2;
760 *ty = (mvy[t1] + mvy[t2]) / 2;
768 /** Do motion compensation for 4-MV macroblock - both chroma blocks
770 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
772 MpegEncContext *s = &v->s;
773 DSPContext *dsp = &v->s.dsp;
774 uint8_t *srcU, *srcV;
775 int uvmx, uvmy, uvsrc_x, uvsrc_y;
776 int k, tx = 0, ty = 0;
777 int mvx[4], mvy[4], intra[4], mv_f[4];
779 int chroma_ref_type = v->cur_field_type, off = 0;
780 int v_edge_pos = s->v_edge_pos >> v->field_mode;
782 if (!v->field_mode && !v->s.last_picture.f.data[0])
784 if (s->flags & CODEC_FLAG_GRAY)
787 for (k = 0; k < 4; k++) {
788 mvx[k] = s->mv[dir][k][0];
789 mvy[k] = s->mv[dir][k][1];
790 intra[k] = v->mb_type[0][s->block_index[k]];
792 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
795 /* calculate chroma MV vector from four luma MVs */
796 if (!v->field_mode || (v->field_mode && !v->numref)) {
797 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
799 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
800 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
801 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
802 return; //no need to do MC for intra blocks
806 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
808 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
810 chroma_ref_type = !v->cur_field_type;
812 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
814 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
815 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
816 uvmx = (tx + ((tx & 3) == 3)) >> 1;
817 uvmy = (ty + ((ty & 3) == 3)) >> 1;
819 v->luma_mv[s->mb_x][0] = uvmx;
820 v->luma_mv[s->mb_x][1] = uvmy;
823 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
824 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
826 // Field conversion bias
827 if (v->cur_field_type != chroma_ref_type)
828 uvmy += 2 - 4 * chroma_ref_type;
830 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
831 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
833 if (v->profile != PROFILE_ADVANCED) {
834 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
835 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
837 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
838 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
843 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
844 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
845 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
847 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
848 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
851 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
852 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
855 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
856 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
860 if (chroma_ref_type) {
861 srcU += s->current_picture_ptr->f.linesize[1];
862 srcV += s->current_picture_ptr->f.linesize[2];
864 off = v->cur_field_type ? s->current_picture_ptr->f.linesize[1] : 0;
867 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
868 || s->h_edge_pos < 18 || v_edge_pos < 18
869 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
870 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
871 s->dsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
872 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
873 s->h_edge_pos >> 1, v_edge_pos >> 1);
874 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
875 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
876 s->h_edge_pos >> 1, v_edge_pos >> 1);
877 srcU = s->edge_emu_buffer;
878 srcV = s->edge_emu_buffer + 16;
880 /* if we deal with range reduction we need to scale source blocks */
881 if (v->rangeredfrm) {
887 for (j = 0; j < 9; j++) {
888 for (i = 0; i < 9; i++) {
889 src[i] = ((src[i] - 128) >> 1) + 128;
890 src2[i] = ((src2[i] - 128) >> 1) + 128;
892 src += s->uvlinesize;
893 src2 += s->uvlinesize;
896 /* if we deal with intensity compensation we need to scale source blocks */
897 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
903 for (j = 0; j < 9; j++) {
904 for (i = 0; i < 9; i++) {
905 src[i] = v->lutuv[src[i]];
906 src2[i] = v->lutuv[src2[i]];
908 src += s->uvlinesize;
909 src2 += s->uvlinesize;
914 /* Chroma MC always uses qpel bilinear */
915 uvmx = (uvmx & 3) << 1;
916 uvmy = (uvmy & 3) << 1;
918 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
919 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
921 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
922 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
926 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
928 static void vc1_mc_4mv_chroma4(VC1Context *v)
930 MpegEncContext *s = &v->s;
931 DSPContext *dsp = &v->s.dsp;
932 uint8_t *srcU, *srcV;
933 int uvsrc_x, uvsrc_y;
934 int uvmx_field[4], uvmy_field[4];
936 int fieldmv = v->blk_mv_type[s->block_index[0]];
937 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
938 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
939 int v_edge_pos = s->v_edge_pos >> 1;
941 if (!v->s.last_picture.f.data[0])
943 if (s->flags & CODEC_FLAG_GRAY)
946 for (i = 0; i < 4; i++) {
948 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
951 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
953 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
956 for (i = 0; i < 4; i++) {
957 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
958 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
959 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
960 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
961 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
962 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
963 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
964 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
965 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
966 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
968 if (fieldmv && !(uvsrc_y & 1))
970 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
972 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
973 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
974 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
975 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
976 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
977 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
978 s->h_edge_pos >> 1, v_edge_pos);
979 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
980 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
981 s->h_edge_pos >> 1, v_edge_pos);
982 srcU = s->edge_emu_buffer;
983 srcV = s->edge_emu_buffer + 16;
985 /* if we deal with intensity compensation we need to scale source blocks */
986 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
992 for (j = 0; j < 5; j++) {
993 for (i = 0; i < 5; i++) {
994 src[i] = v->lutuv[src[i]];
995 src2[i] = v->lutuv[src2[i]];
997 src += s->uvlinesize << 1;
998 src2 += s->uvlinesize << 1;
1003 dsp->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1004 dsp->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1006 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]);
1007 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]);
1012 /***********************************************************************/
1014 * @name VC-1 Block-level functions
1015 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1021 * @brief Get macroblock-level quantizer scale
1023 #define GET_MQUANT() \
1024 if (v->dquantfrm) { \
1026 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1027 if (v->dqbilevel) { \
1028 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1030 mqdiff = get_bits(gb, 3); \
1032 mquant = v->pq + mqdiff; \
1034 mquant = get_bits(gb, 5); \
1037 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1038 edges = 1 << v->dqsbedge; \
1039 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1040 edges = (3 << v->dqsbedge) % 15; \
1041 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1043 if ((edges&1) && !s->mb_x) \
1044 mquant = v->altpq; \
1045 if ((edges&2) && s->first_slice_line) \
1046 mquant = v->altpq; \
1047 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1048 mquant = v->altpq; \
1049 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1050 mquant = v->altpq; \
1054 * @def GET_MVDATA(_dmv_x, _dmv_y)
1055 * @brief Get MV differentials
1056 * @see MVDATA decoding from 8.3.5.2, p(1)20
1057 * @param _dmv_x Horizontal differential for decoded MV
1058 * @param _dmv_y Vertical differential for decoded MV
1060 #define GET_MVDATA(_dmv_x, _dmv_y) \
1061 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1062 VC1_MV_DIFF_VLC_BITS, 2); \
1064 mb_has_coeffs = 1; \
1067 mb_has_coeffs = 0; \
1070 _dmv_x = _dmv_y = 0; \
1071 } else if (index == 35) { \
1072 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1073 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1074 } else if (index == 36) { \
1079 index1 = index % 6; \
1080 if (!s->quarter_sample && index1 == 5) val = 1; \
1082 if (size_table[index1] - val > 0) \
1083 val = get_bits(gb, size_table[index1] - val); \
1085 sign = 0 - (val&1); \
1086 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1088 index1 = index / 6; \
1089 if (!s->quarter_sample && index1 == 5) val = 1; \
1091 if (size_table[index1] - val > 0) \
1092 val = get_bits(gb, size_table[index1] - val); \
1094 sign = 0 - (val & 1); \
1095 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1098 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1099 int *dmv_y, int *pred_flag)
1102 int extend_x = 0, extend_y = 0;
1103 GetBitContext *gb = &v->s.gb;
1106 const int* offs_tab;
1109 bits = VC1_2REF_MVDATA_VLC_BITS;
1112 bits = VC1_1REF_MVDATA_VLC_BITS;
1115 switch (v->dmvrange) {
1123 extend_x = extend_y = 1;
1126 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1128 *dmv_x = get_bits(gb, v->k_x);
1129 *dmv_y = get_bits(gb, v->k_y);
1131 *pred_flag = *dmv_y & 1;
1132 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1137 offs_tab = offset_table2;
1139 offs_tab = offset_table1;
1140 index1 = (index + 1) % 9;
1142 val = get_bits(gb, index1 + extend_x);
1143 sign = 0 -(val & 1);
1144 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1148 offs_tab = offset_table2;
1150 offs_tab = offset_table1;
1151 index1 = (index + 1) / 9;
1152 if (index1 > v->numref) {
1153 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1154 sign = 0 - (val & 1);
1155 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1159 *pred_flag = index1 & 1;
1163 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1165 int scaledvalue, refdist;
1166 int scalesame1, scalesame2;
1167 int scalezone1_x, zone1offset_x;
1168 int table_index = dir ^ v->second_field;
1170 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1171 refdist = v->refdist;
1173 refdist = dir ? v->brfd : v->frfd;
1176 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1177 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1178 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1179 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1184 if (FFABS(n) < scalezone1_x)
1185 scaledvalue = (n * scalesame1) >> 8;
1188 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1190 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1193 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1196 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1198 int scaledvalue, refdist;
1199 int scalesame1, scalesame2;
1200 int scalezone1_y, zone1offset_y;
1201 int table_index = dir ^ v->second_field;
1203 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1204 refdist = v->refdist;
1206 refdist = dir ? v->brfd : v->frfd;
1209 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1210 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1211 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1212 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1217 if (FFABS(n) < scalezone1_y)
1218 scaledvalue = (n * scalesame1) >> 8;
1221 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1223 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1227 if (v->cur_field_type && !v->ref_field_type[dir])
1228 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1230 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1233 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1235 int scalezone1_x, zone1offset_x;
1236 int scaleopp1, scaleopp2, brfd;
1239 brfd = FFMIN(v->brfd, 3);
1240 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1241 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1242 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1243 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1248 if (FFABS(n) < scalezone1_x)
1249 scaledvalue = (n * scaleopp1) >> 8;
1252 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1254 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1257 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1260 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1262 int scalezone1_y, zone1offset_y;
1263 int scaleopp1, scaleopp2, brfd;
1266 brfd = FFMIN(v->brfd, 3);
1267 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1268 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1269 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1270 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1275 if (FFABS(n) < scalezone1_y)
1276 scaledvalue = (n * scaleopp1) >> 8;
1279 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1281 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1284 if (v->cur_field_type && !v->ref_field_type[dir]) {
1285 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1287 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1291 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1294 int brfd, scalesame;
1295 int hpel = 1 - v->s.quarter_sample;
1298 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1300 n = scaleforsame_y(v, i, n, dir) << hpel;
1302 n = scaleforsame_x(v, n, dir) << hpel;
1305 brfd = FFMIN(v->brfd, 3);
1306 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1308 n = (n * scalesame >> 8) << hpel;
1312 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1315 int refdist, scaleopp;
1316 int hpel = 1 - v->s.quarter_sample;
1319 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1321 n = scaleforopp_y(v, n, dir) << hpel;
1323 n = scaleforopp_x(v, n) << hpel;
1326 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1327 refdist = FFMIN(v->refdist, 3);
1329 refdist = dir ? v->brfd : v->frfd;
1330 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1332 n = (n * scaleopp >> 8) << hpel;
1336 /** Predict and set motion vector
1338 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1339 int mv1, int r_x, int r_y, uint8_t* is_intra,
1340 int pred_flag, int dir)
1342 MpegEncContext *s = &v->s;
1343 int xy, wrap, off = 0;
1347 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1348 int opposit, a_f, b_f, c_f;
1349 int16_t field_predA[2];
1350 int16_t field_predB[2];
1351 int16_t field_predC[2];
1352 int a_valid, b_valid, c_valid;
1353 int hybridmv_thresh, y_bias = 0;
1355 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1356 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1360 /* scale MV difference to be quad-pel */
1361 dmv_x <<= 1 - s->quarter_sample;
1362 dmv_y <<= 1 - s->quarter_sample;
1364 wrap = s->b8_stride;
1365 xy = s->block_index[n];
1368 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
1369 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
1370 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
1371 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
1372 if (mv1) { /* duplicate motion data for 1-MV block */
1373 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1374 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1375 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1376 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1377 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1378 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1379 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1380 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1381 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1382 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1383 s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1384 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1385 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1390 C = s->current_picture.f.motion_val[dir][xy - 1 + v->blocks_off];
1391 A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
1393 if (v->field_mode && mixedmv_pic)
1394 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1396 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1398 //in 4-MV mode different blocks have different B predictor position
1401 off = (s->mb_x > 0) ? -1 : 1;
1404 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1413 B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
1415 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1416 b_valid = a_valid && (s->mb_width > 1);
1417 c_valid = s->mb_x || (n == 1 || n == 3);
1418 if (v->field_mode) {
1419 a_valid = a_valid && !is_intra[xy - wrap];
1420 b_valid = b_valid && !is_intra[xy - wrap + off];
1421 c_valid = c_valid && !is_intra[xy - 1];
1425 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1426 num_oppfield += a_f;
1427 num_samefield += 1 - a_f;
1428 field_predA[0] = A[0];
1429 field_predA[1] = A[1];
1431 field_predA[0] = field_predA[1] = 0;
1435 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1436 num_oppfield += b_f;
1437 num_samefield += 1 - b_f;
1438 field_predB[0] = B[0];
1439 field_predB[1] = B[1];
1441 field_predB[0] = field_predB[1] = 0;
1445 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1446 num_oppfield += c_f;
1447 num_samefield += 1 - c_f;
1448 field_predC[0] = C[0];
1449 field_predC[1] = C[1];
1451 field_predC[0] = field_predC[1] = 0;
1455 if (v->field_mode) {
1456 if (num_samefield <= num_oppfield)
1457 opposit = 1 - pred_flag;
1459 opposit = pred_flag;
1463 if (a_valid && !a_f) {
1464 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1465 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1467 if (b_valid && !b_f) {
1468 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1469 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1471 if (c_valid && !c_f) {
1472 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1473 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1475 v->mv_f[dir][xy + v->blocks_off] = 1;
1476 v->ref_field_type[dir] = !v->cur_field_type;
1478 if (a_valid && a_f) {
1479 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1480 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1482 if (b_valid && b_f) {
1483 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1484 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1486 if (c_valid && c_f) {
1487 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1488 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1490 v->mv_f[dir][xy + v->blocks_off] = 0;
1491 v->ref_field_type[dir] = v->cur_field_type;
1495 px = field_predA[0];
1496 py = field_predA[1];
1497 } else if (c_valid) {
1498 px = field_predC[0];
1499 py = field_predC[1];
1500 } else if (b_valid) {
1501 px = field_predB[0];
1502 py = field_predB[1];
1508 if (num_samefield + num_oppfield > 1) {
1509 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1510 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1513 /* Pullback MV as specified in 8.3.5.3.4 */
1514 if (!v->field_mode) {
1516 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1517 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1518 X = (s->mb_width << 6) - 4;
1519 Y = (s->mb_height << 6) - 4;
1521 if (qx + px < -60) px = -60 - qx;
1522 if (qy + py < -60) py = -60 - qy;
1524 if (qx + px < -28) px = -28 - qx;
1525 if (qy + py < -28) py = -28 - qy;
1527 if (qx + px > X) px = X - qx;
1528 if (qy + py > Y) py = Y - qy;
1531 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1532 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1533 hybridmv_thresh = 32;
1534 if (a_valid && c_valid) {
1535 if (is_intra[xy - wrap])
1536 sum = FFABS(px) + FFABS(py);
1538 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1539 if (sum > hybridmv_thresh) {
1540 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1541 px = field_predA[0];
1542 py = field_predA[1];
1544 px = field_predC[0];
1545 py = field_predC[1];
1548 if (is_intra[xy - 1])
1549 sum = FFABS(px) + FFABS(py);
1551 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1552 if (sum > hybridmv_thresh) {
1553 if (get_bits1(&s->gb)) {
1554 px = field_predA[0];
1555 py = field_predA[1];
1557 px = field_predC[0];
1558 py = field_predC[1];
1565 if (v->field_mode && !s->quarter_sample) {
1569 if (v->field_mode && v->numref)
1571 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1573 /* store MV using signed modulus of MV range defined in 4.11 */
1574 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;
1575 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;
1576 if (mv1) { /* duplicate motion data for 1-MV block */
1577 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];
1578 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];
1579 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];
1580 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];
1581 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];
1582 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];
1583 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1584 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];
1588 /** Predict and set motion vector for interlaced frame picture MBs
1590 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1591 int mvn, int r_x, int r_y, uint8_t* is_intra)
1593 MpegEncContext *s = &v->s;
1594 int xy, wrap, off = 0;
1595 int A[2], B[2], C[2];
1597 int a_valid = 0, b_valid = 0, c_valid = 0;
1598 int field_a, field_b, field_c; // 0: same, 1: opposit
1599 int total_valid, num_samefield, num_oppfield;
1600 int pos_c, pos_b, n_adj;
1602 wrap = s->b8_stride;
1603 xy = s->block_index[n];
1606 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
1607 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
1608 s->current_picture.f.motion_val[1][xy][0] = 0;
1609 s->current_picture.f.motion_val[1][xy][1] = 0;
1610 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1611 s->current_picture.f.motion_val[0][xy + 1][0] = 0;
1612 s->current_picture.f.motion_val[0][xy + 1][1] = 0;
1613 s->current_picture.f.motion_val[0][xy + wrap][0] = 0;
1614 s->current_picture.f.motion_val[0][xy + wrap][1] = 0;
1615 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
1616 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
1617 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1618 s->current_picture.f.motion_val[1][xy + 1][0] = 0;
1619 s->current_picture.f.motion_val[1][xy + 1][1] = 0;
1620 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1621 s->current_picture.f.motion_val[1][xy + wrap][1] = 0;
1622 s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
1623 s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
1628 off = ((n == 0) || (n == 1)) ? 1 : -1;
1630 if (s->mb_x || (n == 1) || (n == 3)) {
1631 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1632 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1633 A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
1634 A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
1636 } else { // current block has frame mv and cand. has field MV (so average)
1637 A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
1638 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1639 A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
1640 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1643 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1649 /* Predict B and C */
1650 B[0] = B[1] = C[0] = C[1] = 0;
1651 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1652 if (!s->first_slice_line) {
1653 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1656 pos_b = s->block_index[n_adj] - 2 * wrap;
1657 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1658 n_adj = (n & 2) | (n & 1);
1660 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1661 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1662 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1663 B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1664 B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1667 if (s->mb_width > 1) {
1668 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1671 pos_c = s->block_index[2] - 2 * wrap + 2;
1672 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1675 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1676 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1677 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1678 C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1679 C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1681 if (s->mb_x == s->mb_width - 1) {
1682 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1685 pos_c = s->block_index[3] - 2 * wrap - 2;
1686 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1689 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1690 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1691 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1692 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1693 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1702 pos_b = s->block_index[1];
1704 B[0] = s->current_picture.f.motion_val[0][pos_b][0];
1705 B[1] = s->current_picture.f.motion_val[0][pos_b][1];
1706 pos_c = s->block_index[0];
1708 C[0] = s->current_picture.f.motion_val[0][pos_c][0];
1709 C[1] = s->current_picture.f.motion_val[0][pos_c][1];
1712 total_valid = a_valid + b_valid + c_valid;
1713 // check if predictor A is out of bounds
1714 if (!s->mb_x && !(n == 1 || n == 3)) {
1717 // check if predictor B is out of bounds
1718 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1719 B[0] = B[1] = C[0] = C[1] = 0;
1721 if (!v->blk_mv_type[xy]) {
1722 if (s->mb_width == 1) {
1726 if (total_valid >= 2) {
1727 px = mid_pred(A[0], B[0], C[0]);
1728 py = mid_pred(A[1], B[1], C[1]);
1729 } else if (total_valid) {
1730 if (a_valid) { px = A[0]; py = A[1]; }
1731 if (b_valid) { px = B[0]; py = B[1]; }
1732 if (c_valid) { px = C[0]; py = C[1]; }
1738 field_a = (A[1] & 4) ? 1 : 0;
1742 field_b = (B[1] & 4) ? 1 : 0;
1746 field_c = (C[1] & 4) ? 1 : 0;
1750 num_oppfield = field_a + field_b + field_c;
1751 num_samefield = total_valid - num_oppfield;
1752 if (total_valid == 3) {
1753 if ((num_samefield == 3) || (num_oppfield == 3)) {
1754 px = mid_pred(A[0], B[0], C[0]);
1755 py = mid_pred(A[1], B[1], C[1]);
1756 } else if (num_samefield >= num_oppfield) {
1757 /* take one MV from same field set depending on priority
1758 the check for B may not be necessary */
1759 px = !field_a ? A[0] : B[0];
1760 py = !field_a ? A[1] : B[1];
1762 px = field_a ? A[0] : B[0];
1763 py = field_a ? A[1] : B[1];
1765 } else if (total_valid == 2) {
1766 if (num_samefield >= num_oppfield) {
1767 if (!field_a && a_valid) {
1770 } else if (!field_b && b_valid) {
1773 } else if (c_valid) {
1778 if (field_a && a_valid) {
1781 } else if (field_b && b_valid) {
1784 } else if (c_valid) {
1789 } else if (total_valid == 1) {
1790 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1791 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1796 /* store MV using signed modulus of MV range defined in 4.11 */
1797 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;
1798 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;
1799 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1800 s->current_picture.f.motion_val[0][xy + 1 ][0] = s->current_picture.f.motion_val[0][xy][0];
1801 s->current_picture.f.motion_val[0][xy + 1 ][1] = s->current_picture.f.motion_val[0][xy][1];
1802 s->current_picture.f.motion_val[0][xy + wrap ][0] = s->current_picture.f.motion_val[0][xy][0];
1803 s->current_picture.f.motion_val[0][xy + wrap ][1] = s->current_picture.f.motion_val[0][xy][1];
1804 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1805 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1806 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1807 s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1808 s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1809 s->mv[0][n + 1][0] = s->mv[0][n][0];
1810 s->mv[0][n + 1][1] = s->mv[0][n][1];
1814 /** Motion compensation for direct or interpolated blocks in B-frames
1816 static void vc1_interp_mc(VC1Context *v)
1818 MpegEncContext *s = &v->s;
1819 DSPContext *dsp = &v->s.dsp;
1820 uint8_t *srcY, *srcU, *srcV;
1821 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1823 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1825 if (!v->field_mode && !v->s.next_picture.f.data[0])
1828 mx = s->mv[1][0][0];
1829 my = s->mv[1][0][1];
1830 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1831 uvmy = (my + ((my & 3) == 3)) >> 1;
1832 if (v->field_mode) {
1833 if (v->cur_field_type != v->ref_field_type[1])
1834 my = my - 2 + 4 * v->cur_field_type;
1835 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1838 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1839 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1841 srcY = s->next_picture.f.data[0];
1842 srcU = s->next_picture.f.data[1];
1843 srcV = s->next_picture.f.data[2];
1845 src_x = s->mb_x * 16 + (mx >> 2);
1846 src_y = s->mb_y * 16 + (my >> 2);
1847 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1848 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1850 if (v->profile != PROFILE_ADVANCED) {
1851 src_x = av_clip( src_x, -16, s->mb_width * 16);
1852 src_y = av_clip( src_y, -16, s->mb_height * 16);
1853 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1854 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1856 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1857 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1858 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1859 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1862 srcY += src_y * s->linesize + src_x;
1863 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1864 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1866 if (v->field_mode && v->ref_field_type[1]) {
1867 srcY += s->current_picture_ptr->f.linesize[0];
1868 srcU += s->current_picture_ptr->f.linesize[1];
1869 srcV += s->current_picture_ptr->f.linesize[2];
1872 /* for grayscale we should not try to read from unknown area */
1873 if (s->flags & CODEC_FLAG_GRAY) {
1874 srcU = s->edge_emu_buffer + 18 * s->linesize;
1875 srcV = s->edge_emu_buffer + 18 * s->linesize;
1878 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1879 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 16 - s->mspel * 3
1880 || (unsigned)(src_y - s->mspel) > v_edge_pos - (my & 3) - 16 - s->mspel * 3) {
1881 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1883 srcY -= s->mspel * (1 + s->linesize);
1884 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1885 17 + s->mspel * 2, 17 + s->mspel * 2,
1886 src_x - s->mspel, src_y - s->mspel,
1887 s->h_edge_pos, v_edge_pos);
1888 srcY = s->edge_emu_buffer;
1889 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1890 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1891 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1892 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1895 /* if we deal with range reduction we need to scale source blocks */
1896 if (v->rangeredfrm) {
1898 uint8_t *src, *src2;
1901 for (j = 0; j < 17 + s->mspel * 2; j++) {
1902 for (i = 0; i < 17 + s->mspel * 2; i++)
1903 src[i] = ((src[i] - 128) >> 1) + 128;
1908 for (j = 0; j < 9; j++) {
1909 for (i = 0; i < 9; i++) {
1910 src[i] = ((src[i] - 128) >> 1) + 128;
1911 src2[i] = ((src2[i] - 128) >> 1) + 128;
1913 src += s->uvlinesize;
1914 src2 += s->uvlinesize;
1917 srcY += s->mspel * (1 + s->linesize);
1920 if (v->field_mode && v->cur_field_type) {
1921 off = s->current_picture_ptr->f.linesize[0];
1922 off_uv = s->current_picture_ptr->f.linesize[1];
1929 dxy = ((my & 3) << 2) | (mx & 3);
1930 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
1931 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1932 srcY += s->linesize * 8;
1933 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
1934 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1936 dxy = (my & 2) | ((mx & 2) >> 1);
1939 dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1941 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1944 if (s->flags & CODEC_FLAG_GRAY) return;
1945 /* Chroma MC always uses qpel blilinear */
1946 uvmx = (uvmx & 3) << 1;
1947 uvmy = (uvmy & 3) << 1;
1949 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1950 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1952 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1953 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1957 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1961 #if B_FRACTION_DEN==256
1965 return 2 * ((value * n + 255) >> 9);
1966 return (value * n + 128) >> 8;
1969 n -= B_FRACTION_DEN;
1971 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1972 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1976 static av_always_inline int scale_mv_intfi(int value, int bfrac, int inv,
1977 int qs, int qs_last)
1985 return (value * n + 255) >> 9;
1987 return (value * n + 128) >> 8;
1990 /** Reconstruct motion vector for B-frame and do motion compensation
1992 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
1993 int direct, int mode)
1996 v->mv_mode2 = v->mv_mode;
1997 v->mv_mode = MV_PMODE_INTENSITY_COMP;
2003 v->mv_mode = v->mv_mode2;
2006 if (mode == BMV_TYPE_INTERPOLATED) {
2010 v->mv_mode = v->mv_mode2;
2014 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2015 v->mv_mode = v->mv_mode2;
2016 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2018 v->mv_mode = v->mv_mode2;
2021 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2022 int direct, int mvtype)
2024 MpegEncContext *s = &v->s;
2025 int xy, wrap, off = 0;
2030 const uint8_t *is_intra = v->mb_type[0];
2034 /* scale MV difference to be quad-pel */
2035 dmv_x[0] <<= 1 - s->quarter_sample;
2036 dmv_y[0] <<= 1 - s->quarter_sample;
2037 dmv_x[1] <<= 1 - s->quarter_sample;
2038 dmv_y[1] <<= 1 - s->quarter_sample;
2040 wrap = s->b8_stride;
2041 xy = s->block_index[0];
2044 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
2045 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
2046 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
2047 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
2050 if (!v->field_mode) {
2051 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2052 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2053 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2054 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2056 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2057 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));
2058 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));
2059 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));
2060 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));
2063 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2064 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2065 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2066 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2070 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2071 C = s->current_picture.f.motion_val[0][xy - 2];
2072 A = s->current_picture.f.motion_val[0][xy - wrap * 2];
2073 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2074 B = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
2076 if (!s->mb_x) C[0] = C[1] = 0;
2077 if (!s->first_slice_line) { // predictor A is not out of bounds
2078 if (s->mb_width == 1) {
2082 px = mid_pred(A[0], B[0], C[0]);
2083 py = mid_pred(A[1], B[1], C[1]);
2085 } else if (s->mb_x) { // predictor C is not out of bounds
2091 /* Pullback MV as specified in 8.3.5.3.4 */
2094 if (v->profile < PROFILE_ADVANCED) {
2095 qx = (s->mb_x << 5);
2096 qy = (s->mb_y << 5);
2097 X = (s->mb_width << 5) - 4;
2098 Y = (s->mb_height << 5) - 4;
2099 if (qx + px < -28) px = -28 - qx;
2100 if (qy + py < -28) py = -28 - qy;
2101 if (qx + px > X) px = X - qx;
2102 if (qy + py > Y) py = Y - qy;
2104 qx = (s->mb_x << 6);
2105 qy = (s->mb_y << 6);
2106 X = (s->mb_width << 6) - 4;
2107 Y = (s->mb_height << 6) - 4;
2108 if (qx + px < -60) px = -60 - qx;
2109 if (qy + py < -60) py = -60 - qy;
2110 if (qx + px > X) px = X - qx;
2111 if (qy + py > Y) py = Y - qy;
2114 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2115 if (0 && !s->first_slice_line && s->mb_x) {
2116 if (is_intra[xy - wrap])
2117 sum = FFABS(px) + FFABS(py);
2119 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2121 if (get_bits1(&s->gb)) {
2129 if (is_intra[xy - 2])
2130 sum = FFABS(px) + FFABS(py);
2132 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2134 if (get_bits1(&s->gb)) {
2144 /* store MV using signed modulus of MV range defined in 4.11 */
2145 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2146 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2148 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2149 C = s->current_picture.f.motion_val[1][xy - 2];
2150 A = s->current_picture.f.motion_val[1][xy - wrap * 2];
2151 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2152 B = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
2156 if (!s->first_slice_line) { // predictor A is not out of bounds
2157 if (s->mb_width == 1) {
2161 px = mid_pred(A[0], B[0], C[0]);
2162 py = mid_pred(A[1], B[1], C[1]);
2164 } else if (s->mb_x) { // predictor C is not out of bounds
2170 /* Pullback MV as specified in 8.3.5.3.4 */
2173 if (v->profile < PROFILE_ADVANCED) {
2174 qx = (s->mb_x << 5);
2175 qy = (s->mb_y << 5);
2176 X = (s->mb_width << 5) - 4;
2177 Y = (s->mb_height << 5) - 4;
2178 if (qx + px < -28) px = -28 - qx;
2179 if (qy + py < -28) py = -28 - qy;
2180 if (qx + px > X) px = X - qx;
2181 if (qy + py > Y) py = Y - qy;
2183 qx = (s->mb_x << 6);
2184 qy = (s->mb_y << 6);
2185 X = (s->mb_width << 6) - 4;
2186 Y = (s->mb_height << 6) - 4;
2187 if (qx + px < -60) px = -60 - qx;
2188 if (qy + py < -60) py = -60 - qy;
2189 if (qx + px > X) px = X - qx;
2190 if (qy + py > Y) py = Y - qy;
2193 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2194 if (0 && !s->first_slice_line && s->mb_x) {
2195 if (is_intra[xy - wrap])
2196 sum = FFABS(px) + FFABS(py);
2198 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2200 if (get_bits1(&s->gb)) {
2208 if (is_intra[xy - 2])
2209 sum = FFABS(px) + FFABS(py);
2211 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2213 if (get_bits1(&s->gb)) {
2223 /* store MV using signed modulus of MV range defined in 4.11 */
2225 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2226 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2228 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
2229 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
2230 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
2231 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
2234 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2236 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2237 MpegEncContext *s = &v->s;
2238 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2240 if (v->bmvtype == BMV_TYPE_DIRECT) {
2241 int total_opp, k, f;
2242 if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2243 s->mv[0][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2244 v->bfraction, 0, s->quarter_sample, v->qs_last);
2245 s->mv[0][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2246 v->bfraction, 0, s->quarter_sample, v->qs_last);
2247 s->mv[1][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2248 v->bfraction, 1, s->quarter_sample, v->qs_last);
2249 s->mv[1][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2250 v->bfraction, 1, s->quarter_sample, v->qs_last);
2252 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2253 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2254 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2255 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2256 f = (total_opp > 2) ? 1 : 0;
2258 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2259 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2262 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2263 for (k = 0; k < 4; k++) {
2264 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2265 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2266 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2267 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2268 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2269 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2273 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2274 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);
2275 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);
2278 if (dir) { // backward
2279 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);
2280 if (n == 3 || mv1) {
2281 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2284 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);
2285 if (n == 3 || mv1) {
2286 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2291 /** Get predicted DC value for I-frames only
2292 * prediction dir: left=0, top=1
2293 * @param s MpegEncContext
2294 * @param overlap flag indicating that overlap filtering is used
2295 * @param pq integer part of picture quantizer
2296 * @param[in] n block index in the current MB
2297 * @param dc_val_ptr Pointer to DC predictor
2298 * @param dir_ptr Prediction direction for use in AC prediction
2300 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2301 int16_t **dc_val_ptr, int *dir_ptr)
2303 int a, b, c, wrap, pred, scale;
2305 static const uint16_t dcpred[32] = {
2306 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2307 114, 102, 93, 85, 79, 73, 68, 64,
2308 60, 57, 54, 51, 49, 47, 45, 43,
2309 41, 39, 38, 37, 35, 34, 33
2312 /* find prediction - wmv3_dc_scale always used here in fact */
2313 if (n < 4) scale = s->y_dc_scale;
2314 else scale = s->c_dc_scale;
2316 wrap = s->block_wrap[n];
2317 dc_val = s->dc_val[0] + s->block_index[n];
2323 b = dc_val[ - 1 - wrap];
2324 a = dc_val[ - wrap];
2326 if (pq < 9 || !overlap) {
2327 /* Set outer values */
2328 if (s->first_slice_line && (n != 2 && n != 3))
2329 b = a = dcpred[scale];
2330 if (s->mb_x == 0 && (n != 1 && n != 3))
2331 b = c = dcpred[scale];
2333 /* Set outer values */
2334 if (s->first_slice_line && (n != 2 && n != 3))
2336 if (s->mb_x == 0 && (n != 1 && n != 3))
2340 if (abs(a - b) <= abs(b - c)) {
2342 *dir_ptr = 1; // left
2345 *dir_ptr = 0; // top
2348 /* update predictor */
2349 *dc_val_ptr = &dc_val[0];
2354 /** Get predicted DC value
2355 * prediction dir: left=0, top=1
2356 * @param s MpegEncContext
2357 * @param overlap flag indicating that overlap filtering is used
2358 * @param pq integer part of picture quantizer
2359 * @param[in] n block index in the current MB
2360 * @param a_avail flag indicating top block availability
2361 * @param c_avail flag indicating left block availability
2362 * @param dc_val_ptr Pointer to DC predictor
2363 * @param dir_ptr Prediction direction for use in AC prediction
2365 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2366 int a_avail, int c_avail,
2367 int16_t **dc_val_ptr, int *dir_ptr)
2369 int a, b, c, wrap, pred;
2371 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2375 wrap = s->block_wrap[n];
2376 dc_val = s->dc_val[0] + s->block_index[n];
2382 b = dc_val[ - 1 - wrap];
2383 a = dc_val[ - wrap];
2384 /* scale predictors if needed */
2385 q1 = s->current_picture.f.qscale_table[mb_pos];
2386 dqscale_index = s->y_dc_scale_table[q1] - 1;
2387 if (dqscale_index < 0)
2389 if (c_avail && (n != 1 && n != 3)) {
2390 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2392 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2394 if (a_avail && (n != 2 && n != 3)) {
2395 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2397 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2399 if (a_avail && c_avail && (n != 3)) {
2404 off -= s->mb_stride;
2405 q2 = s->current_picture.f.qscale_table[off];
2407 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2410 if (a_avail && c_avail) {
2411 if (abs(a - b) <= abs(b - c)) {
2413 *dir_ptr = 1; // left
2416 *dir_ptr = 0; // top
2418 } else if (a_avail) {
2420 *dir_ptr = 0; // top
2421 } else if (c_avail) {
2423 *dir_ptr = 1; // left
2426 *dir_ptr = 1; // left
2429 /* update predictor */
2430 *dc_val_ptr = &dc_val[0];
2434 /** @} */ // Block group
2437 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2438 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2442 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2443 uint8_t **coded_block_ptr)
2445 int xy, wrap, pred, a, b, c;
2447 xy = s->block_index[n];
2448 wrap = s->b8_stride;
2453 a = s->coded_block[xy - 1 ];
2454 b = s->coded_block[xy - 1 - wrap];
2455 c = s->coded_block[xy - wrap];
2464 *coded_block_ptr = &s->coded_block[xy];
2470 * Decode one AC coefficient
2471 * @param v The VC1 context
2472 * @param last Last coefficient
2473 * @param skip How much zero coefficients to skip
2474 * @param value Decoded AC coefficient value
2475 * @param codingset set of VLC to decode data
2478 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2479 int *value, int codingset)
2481 GetBitContext *gb = &v->s.gb;
2482 int index, escape, run = 0, level = 0, lst = 0;
2484 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2485 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2486 run = vc1_index_decode_table[codingset][index][0];
2487 level = vc1_index_decode_table[codingset][index][1];
2488 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2492 escape = decode210(gb);
2494 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2495 run = vc1_index_decode_table[codingset][index][0];
2496 level = vc1_index_decode_table[codingset][index][1];
2497 lst = index >= vc1_last_decode_table[codingset];
2500 level += vc1_last_delta_level_table[codingset][run];
2502 level += vc1_delta_level_table[codingset][run];
2505 run += vc1_last_delta_run_table[codingset][level] + 1;
2507 run += vc1_delta_run_table[codingset][level] + 1;
2513 lst = get_bits1(gb);
2514 if (v->s.esc3_level_length == 0) {
2515 if (v->pq < 8 || v->dquantfrm) { // table 59
2516 v->s.esc3_level_length = get_bits(gb, 3);
2517 if (!v->s.esc3_level_length)
2518 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2519 } else { // table 60
2520 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2522 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2524 run = get_bits(gb, v->s.esc3_run_length);
2525 sign = get_bits1(gb);
2526 level = get_bits(gb, v->s.esc3_level_length);
2537 /** Decode intra block in intra frames - should be faster than decode_intra_block
2538 * @param v VC1Context
2539 * @param block block to decode
2540 * @param[in] n subblock index
2541 * @param coded are AC coeffs present or not
2542 * @param codingset set of VLC to decode data
2544 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
2545 int coded, int codingset)
2547 GetBitContext *gb = &v->s.gb;
2548 MpegEncContext *s = &v->s;
2549 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2552 int16_t *ac_val, *ac_val2;
2555 /* Get DC differential */
2557 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2559 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2562 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2566 if (dcdiff == 119 /* ESC index value */) {
2567 /* TODO: Optimize */
2568 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2569 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2570 else dcdiff = get_bits(gb, 8);
2573 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2574 else if (v->pq == 2)
2575 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2582 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2585 /* Store the quantized DC coeff, used for prediction */
2587 block[0] = dcdiff * s->y_dc_scale;
2589 block[0] = dcdiff * s->c_dc_scale;
2600 int last = 0, skip, value;
2601 const uint8_t *zz_table;
2605 scale = v->pq * 2 + v->halfpq;
2609 zz_table = v->zz_8x8[2];
2611 zz_table = v->zz_8x8[3];
2613 zz_table = v->zz_8x8[1];
2615 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2617 if (dc_pred_dir) // left
2620 ac_val -= 16 * s->block_wrap[n];
2623 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2627 block[zz_table[i++]] = value;
2630 /* apply AC prediction if needed */
2632 if (dc_pred_dir) { // left
2633 for (k = 1; k < 8; k++)
2634 block[k << v->left_blk_sh] += ac_val[k];
2636 for (k = 1; k < 8; k++)
2637 block[k << v->top_blk_sh] += ac_val[k + 8];
2640 /* save AC coeffs for further prediction */
2641 for (k = 1; k < 8; k++) {
2642 ac_val2[k] = block[k << v->left_blk_sh];
2643 ac_val2[k + 8] = block[k << v->top_blk_sh];
2646 /* scale AC coeffs */
2647 for (k = 1; k < 64; k++)
2651 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2654 if (s->ac_pred) i = 63;
2660 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2664 scale = v->pq * 2 + v->halfpq;
2665 memset(ac_val2, 0, 16 * 2);
2666 if (dc_pred_dir) { // left
2669 memcpy(ac_val2, ac_val, 8 * 2);
2671 ac_val -= 16 * s->block_wrap[n];
2673 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2676 /* apply AC prediction if needed */
2678 if (dc_pred_dir) { //left
2679 for (k = 1; k < 8; k++) {
2680 block[k << v->left_blk_sh] = ac_val[k] * scale;
2681 if (!v->pquantizer && block[k << v->left_blk_sh])
2682 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2685 for (k = 1; k < 8; k++) {
2686 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2687 if (!v->pquantizer && block[k << v->top_blk_sh])
2688 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2694 s->block_last_index[n] = i;
2699 /** Decode intra block in intra frames - should be faster than decode_intra_block
2700 * @param v VC1Context
2701 * @param block block to decode
2702 * @param[in] n subblock number
2703 * @param coded are AC coeffs present or not
2704 * @param codingset set of VLC to decode data
2705 * @param mquant quantizer value for this macroblock
2707 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
2708 int coded, int codingset, int mquant)
2710 GetBitContext *gb = &v->s.gb;
2711 MpegEncContext *s = &v->s;
2712 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2715 int16_t *ac_val, *ac_val2;
2717 int a_avail = v->a_avail, c_avail = v->c_avail;
2718 int use_pred = s->ac_pred;
2721 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2723 /* Get DC differential */
2725 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2727 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2730 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2734 if (dcdiff == 119 /* ESC index value */) {
2735 /* TODO: Optimize */
2736 if (mquant == 1) dcdiff = get_bits(gb, 10);
2737 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2738 else dcdiff = get_bits(gb, 8);
2741 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2742 else if (mquant == 2)
2743 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2750 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2753 /* Store the quantized DC coeff, used for prediction */
2755 block[0] = dcdiff * s->y_dc_scale;
2757 block[0] = dcdiff * s->c_dc_scale;
2763 /* check if AC is needed at all */
2764 if (!a_avail && !c_avail)
2766 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2769 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2771 if (dc_pred_dir) // left
2774 ac_val -= 16 * s->block_wrap[n];
2776 q1 = s->current_picture.f.qscale_table[mb_pos];
2777 if ( dc_pred_dir && c_avail && mb_pos)
2778 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2779 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2780 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2781 if ( dc_pred_dir && n == 1)
2783 if (!dc_pred_dir && n == 2)
2789 int last = 0, skip, value;
2790 const uint8_t *zz_table;
2794 if (!use_pred && v->fcm == ILACE_FRAME) {
2795 zz_table = v->zzi_8x8;
2797 if (!dc_pred_dir) // top
2798 zz_table = v->zz_8x8[2];
2800 zz_table = v->zz_8x8[3];
2803 if (v->fcm != ILACE_FRAME)
2804 zz_table = v->zz_8x8[1];
2806 zz_table = v->zzi_8x8;
2810 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2814 block[zz_table[i++]] = value;
2817 /* apply AC prediction if needed */
2819 /* scale predictors if needed*/
2820 if (q2 && q1 != q2) {
2821 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2822 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2825 return AVERROR_INVALIDDATA;
2826 if (dc_pred_dir) { // left
2827 for (k = 1; k < 8; k++)
2828 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2830 for (k = 1; k < 8; k++)
2831 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2834 if (dc_pred_dir) { //left
2835 for (k = 1; k < 8; k++)
2836 block[k << v->left_blk_sh] += ac_val[k];
2838 for (k = 1; k < 8; k++)
2839 block[k << v->top_blk_sh] += ac_val[k + 8];
2843 /* save AC coeffs for further prediction */
2844 for (k = 1; k < 8; k++) {
2845 ac_val2[k ] = block[k << v->left_blk_sh];
2846 ac_val2[k + 8] = block[k << v->top_blk_sh];
2849 /* scale AC coeffs */
2850 for (k = 1; k < 64; k++)
2854 block[k] += (block[k] < 0) ? -mquant : mquant;
2857 if (use_pred) i = 63;
2858 } else { // no AC coeffs
2861 memset(ac_val2, 0, 16 * 2);
2862 if (dc_pred_dir) { // left
2864 memcpy(ac_val2, ac_val, 8 * 2);
2865 if (q2 && q1 != q2) {
2866 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2867 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2869 return AVERROR_INVALIDDATA;
2870 for (k = 1; k < 8; k++)
2871 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2876 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2877 if (q2 && q1 != q2) {
2878 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2879 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2881 return AVERROR_INVALIDDATA;
2882 for (k = 1; k < 8; k++)
2883 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2888 /* apply AC prediction if needed */
2890 if (dc_pred_dir) { // left
2891 for (k = 1; k < 8; k++) {
2892 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2893 if (!v->pquantizer && block[k << v->left_blk_sh])
2894 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2897 for (k = 1; k < 8; k++) {
2898 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2899 if (!v->pquantizer && block[k << v->top_blk_sh])
2900 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2906 s->block_last_index[n] = i;
2911 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2912 * @param v VC1Context
2913 * @param block block to decode
2914 * @param[in] n subblock index
2915 * @param coded are AC coeffs present or not
2916 * @param mquant block quantizer
2917 * @param codingset set of VLC to decode data
2919 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
2920 int coded, int mquant, int codingset)
2922 GetBitContext *gb = &v->s.gb;
2923 MpegEncContext *s = &v->s;
2924 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2927 int16_t *ac_val, *ac_val2;
2929 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2930 int a_avail = v->a_avail, c_avail = v->c_avail;
2931 int use_pred = s->ac_pred;
2935 s->dsp.clear_block(block);
2937 /* XXX: Guard against dumb values of mquant */
2938 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2940 /* Set DC scale - y and c use the same */
2941 s->y_dc_scale = s->y_dc_scale_table[mquant];
2942 s->c_dc_scale = s->c_dc_scale_table[mquant];
2944 /* Get DC differential */
2946 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2948 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2951 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2955 if (dcdiff == 119 /* ESC index value */) {
2956 /* TODO: Optimize */
2957 if (mquant == 1) dcdiff = get_bits(gb, 10);
2958 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2959 else dcdiff = get_bits(gb, 8);
2962 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2963 else if (mquant == 2)
2964 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2971 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2974 /* Store the quantized DC coeff, used for prediction */
2977 block[0] = dcdiff * s->y_dc_scale;
2979 block[0] = dcdiff * s->c_dc_scale;
2985 /* check if AC is needed at all and adjust direction if needed */
2986 if (!a_avail) dc_pred_dir = 1;
2987 if (!c_avail) dc_pred_dir = 0;
2988 if (!a_avail && !c_avail) use_pred = 0;
2989 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2992 scale = mquant * 2 + v->halfpq;
2994 if (dc_pred_dir) //left
2997 ac_val -= 16 * s->block_wrap[n];
2999 q1 = s->current_picture.f.qscale_table[mb_pos];
3000 if (dc_pred_dir && c_avail && mb_pos)
3001 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
3002 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3003 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
3004 if ( dc_pred_dir && n == 1)
3006 if (!dc_pred_dir && n == 2)
3008 if (n == 3) q2 = q1;
3011 int last = 0, skip, value;
3015 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3019 if (v->fcm == PROGRESSIVE)
3020 block[v->zz_8x8[0][i++]] = value;
3022 if (use_pred && (v->fcm == ILACE_FRAME)) {
3023 if (!dc_pred_dir) // top
3024 block[v->zz_8x8[2][i++]] = value;
3026 block[v->zz_8x8[3][i++]] = value;
3028 block[v->zzi_8x8[i++]] = value;
3033 /* apply AC prediction if needed */
3035 /* scale predictors if needed*/
3036 if (q2 && q1 != q2) {
3037 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3038 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3041 return AVERROR_INVALIDDATA;
3042 if (dc_pred_dir) { // left
3043 for (k = 1; k < 8; k++)
3044 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3046 for (k = 1; k < 8; k++)
3047 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3050 if (dc_pred_dir) { // left
3051 for (k = 1; k < 8; k++)
3052 block[k << v->left_blk_sh] += ac_val[k];
3054 for (k = 1; k < 8; k++)
3055 block[k << v->top_blk_sh] += ac_val[k + 8];
3059 /* save AC coeffs for further prediction */
3060 for (k = 1; k < 8; k++) {
3061 ac_val2[k ] = block[k << v->left_blk_sh];
3062 ac_val2[k + 8] = block[k << v->top_blk_sh];
3065 /* scale AC coeffs */
3066 for (k = 1; k < 64; k++)
3070 block[k] += (block[k] < 0) ? -mquant : mquant;
3073 if (use_pred) i = 63;
3074 } else { // no AC coeffs
3077 memset(ac_val2, 0, 16 * 2);
3078 if (dc_pred_dir) { // left
3080 memcpy(ac_val2, ac_val, 8 * 2);
3081 if (q2 && q1 != q2) {
3082 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3083 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3085 return AVERROR_INVALIDDATA;
3086 for (k = 1; k < 8; k++)
3087 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3092 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3093 if (q2 && q1 != q2) {
3094 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3095 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3097 return AVERROR_INVALIDDATA;
3098 for (k = 1; k < 8; k++)
3099 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3104 /* apply AC prediction if needed */
3106 if (dc_pred_dir) { // left
3107 for (k = 1; k < 8; k++) {
3108 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3109 if (!v->pquantizer && block[k << v->left_blk_sh])
3110 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3113 for (k = 1; k < 8; k++) {
3114 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3115 if (!v->pquantizer && block[k << v->top_blk_sh])
3116 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3122 s->block_last_index[n] = i;
3129 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
3130 int mquant, int ttmb, int first_block,
3131 uint8_t *dst, int linesize, int skip_block,
3134 MpegEncContext *s = &v->s;
3135 GetBitContext *gb = &s->gb;
3138 int scale, off, idx, last, skip, value;
3139 int ttblk = ttmb & 7;
3142 s->dsp.clear_block(block);
3145 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)];
3147 if (ttblk == TT_4X4) {
3148 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3150 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3151 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3152 || (!v->res_rtm_flag && !first_block))) {
3153 subblkpat = decode012(gb);
3155 subblkpat ^= 3; // swap decoded pattern bits
3156 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3158 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3161 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3163 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3164 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3165 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3168 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3169 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3178 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3183 idx = v->zz_8x8[0][i++];
3185 idx = v->zzi_8x8[i++];
3186 block[idx] = value * scale;
3188 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3192 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3194 v->vc1dsp.vc1_inv_trans_8x8(block);
3195 s->dsp.add_pixels_clamped(block, dst, linesize);
3200 pat = ~subblkpat & 0xF;
3201 for (j = 0; j < 4; j++) {
3202 last = subblkpat & (1 << (3 - j));
3204 off = (j & 1) * 4 + (j & 2) * 16;
3206 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3211 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3213 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3214 block[idx + off] = value * scale;
3216 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3218 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3220 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3222 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3227 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3228 for (j = 0; j < 2; j++) {
3229 last = subblkpat & (1 << (1 - j));
3233 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3238 idx = v->zz_8x4[i++] + off;
3240 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3241 block[idx] = value * scale;
3243 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3245 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3247 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3249 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3254 pat = ~(subblkpat * 5) & 0xF;
3255 for (j = 0; j < 2; j++) {
3256 last = subblkpat & (1 << (1 - j));
3260 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3265 idx = v->zz_4x8[i++] + off;
3267 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3268 block[idx] = value * scale;
3270 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3272 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3274 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3276 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3282 *ttmb_out |= ttblk << (n * 4);
3286 /** @} */ // Macroblock group
3288 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3289 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3291 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3293 MpegEncContext *s = &v->s;
3294 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3295 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3296 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3297 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3298 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3301 if (block_num > 3) {
3302 dst = s->dest[block_num - 3];
3304 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3306 if (s->mb_y != s->end_mb_y || block_num < 2) {
3310 if (block_num > 3) {
3311 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3312 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3313 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3314 mv_stride = s->mb_stride;
3316 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3317 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3318 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3319 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3320 mv_stride = s->b8_stride;
3321 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3324 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3325 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3326 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3328 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3330 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3333 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3335 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3340 dst -= 4 * linesize;
3341 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3342 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3343 idx = (block_cbp | (block_cbp >> 2)) & 3;
3345 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3348 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3350 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3355 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3357 MpegEncContext *s = &v->s;
3358 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3359 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3360 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3361 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3362 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3365 if (block_num > 3) {
3366 dst = s->dest[block_num - 3] - 8 * linesize;
3368 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3371 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3374 if (block_num > 3) {
3375 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3376 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3377 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3379 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3380 : (mb_cbp >> ((block_num + 1) * 4));
3381 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3382 : (mb_is_intra >> ((block_num + 1) * 4));
3383 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3385 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3386 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3388 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3390 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3393 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3395 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3401 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3402 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3403 idx = (block_cbp | (block_cbp >> 1)) & 5;
3405 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3408 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3410 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3415 static void vc1_apply_p_loop_filter(VC1Context *v)
3417 MpegEncContext *s = &v->s;
3420 for (i = 0; i < 6; i++) {
3421 vc1_apply_p_v_loop_filter(v, i);
3424 /* V always precedes H, therefore we run H one MB before V;
3425 * at the end of a row, we catch up to complete the row */
3427 for (i = 0; i < 6; i++) {
3428 vc1_apply_p_h_loop_filter(v, i);
3430 if (s->mb_x == s->mb_width - 1) {
3432 ff_update_block_index(s);
3433 for (i = 0; i < 6; i++) {
3434 vc1_apply_p_h_loop_filter(v, i);
3440 /** Decode one P-frame MB
3442 static int vc1_decode_p_mb(VC1Context *v)
3444 MpegEncContext *s = &v->s;
3445 GetBitContext *gb = &s->gb;
3447 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3448 int cbp; /* cbp decoding stuff */
3449 int mqdiff, mquant; /* MB quantization */
3450 int ttmb = v->ttfrm; /* MB Transform type */
3452 int mb_has_coeffs = 1; /* last_flag */
3453 int dmv_x, dmv_y; /* Differential MV components */
3454 int index, index1; /* LUT indexes */
3455 int val, sign; /* temp values */
3456 int first_block = 1;
3458 int skipped, fourmv;
3459 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3461 mquant = v->pq; /* lossy initialization */
3463 if (v->mv_type_is_raw)
3464 fourmv = get_bits1(gb);
3466 fourmv = v->mv_type_mb_plane[mb_pos];
3468 skipped = get_bits1(gb);
3470 skipped = v->s.mbskip_table[mb_pos];
3472 if (!fourmv) { /* 1MV mode */
3474 GET_MVDATA(dmv_x, dmv_y);
3477 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3478 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3480 s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3481 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3483 /* FIXME Set DC val for inter block ? */
3484 if (s->mb_intra && !mb_has_coeffs) {
3486 s->ac_pred = get_bits1(gb);
3488 } else if (mb_has_coeffs) {
3490 s->ac_pred = get_bits1(gb);
3491 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3497 s->current_picture.f.qscale_table[mb_pos] = mquant;
3499 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3500 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3501 VC1_TTMB_VLC_BITS, 2);
3502 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3504 for (i = 0; i < 6; i++) {
3505 s->dc_val[0][s->block_index[i]] = 0;
3507 val = ((cbp >> (5 - i)) & 1);
3508 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3509 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3511 /* check if prediction blocks A and C are available */
3512 v->a_avail = v->c_avail = 0;
3513 if (i == 2 || i == 3 || !s->first_slice_line)
3514 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3515 if (i == 1 || i == 3 || s->mb_x)
3516 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3518 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3519 (i & 4) ? v->codingset2 : v->codingset);
3520 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3522 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3524 for (j = 0; j < 64; j++)
3525 s->block[i][j] <<= 1;
3526 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3527 if (v->pq >= 9 && v->overlap) {
3529 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3531 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3533 block_cbp |= 0xF << (i << 2);
3534 block_intra |= 1 << i;
3536 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3537 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3538 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3539 block_cbp |= pat << (i << 2);
3540 if (!v->ttmbf && ttmb < 8)
3547 for (i = 0; i < 6; i++) {
3548 v->mb_type[0][s->block_index[i]] = 0;
3549 s->dc_val[0][s->block_index[i]] = 0;
3551 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3552 s->current_picture.f.qscale_table[mb_pos] = 0;
3553 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3556 } else { // 4MV mode
3557 if (!skipped /* unskipped MB */) {
3558 int intra_count = 0, coded_inter = 0;
3559 int is_intra[6], is_coded[6];
3561 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3562 for (i = 0; i < 6; i++) {
3563 val = ((cbp >> (5 - i)) & 1);
3564 s->dc_val[0][s->block_index[i]] = 0;
3571 GET_MVDATA(dmv_x, dmv_y);
3573 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3575 vc1_mc_4mv_luma(v, i, 0);
3576 intra_count += s->mb_intra;
3577 is_intra[i] = s->mb_intra;
3578 is_coded[i] = mb_has_coeffs;
3581 is_intra[i] = (intra_count >= 3);
3585 vc1_mc_4mv_chroma(v, 0);
3586 v->mb_type[0][s->block_index[i]] = is_intra[i];
3588 coded_inter = !is_intra[i] & is_coded[i];
3590 // if there are no coded blocks then don't do anything more
3592 if (!intra_count && !coded_inter)
3595 s->current_picture.f.qscale_table[mb_pos] = mquant;
3596 /* test if block is intra and has pred */
3599 for (i = 0; i < 6; i++)
3601 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3602 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3608 s->ac_pred = get_bits1(gb);
3612 if (!v->ttmbf && coded_inter)
3613 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3614 for (i = 0; i < 6; i++) {
3616 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3617 s->mb_intra = is_intra[i];
3619 /* check if prediction blocks A and C are available */
3620 v->a_avail = v->c_avail = 0;
3621 if (i == 2 || i == 3 || !s->first_slice_line)
3622 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3623 if (i == 1 || i == 3 || s->mb_x)
3624 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3626 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3627 (i & 4) ? v->codingset2 : v->codingset);
3628 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3630 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3632 for (j = 0; j < 64; j++)
3633 s->block[i][j] <<= 1;
3634 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3635 (i & 4) ? s->uvlinesize : s->linesize);
3636 if (v->pq >= 9 && v->overlap) {
3638 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3640 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3642 block_cbp |= 0xF << (i << 2);
3643 block_intra |= 1 << i;
3644 } else if (is_coded[i]) {
3645 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3646 first_block, s->dest[dst_idx] + off,
3647 (i & 4) ? s->uvlinesize : s->linesize,
3648 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3650 block_cbp |= pat << (i << 2);
3651 if (!v->ttmbf && ttmb < 8)
3656 } else { // skipped MB
3658 s->current_picture.f.qscale_table[mb_pos] = 0;
3659 for (i = 0; i < 6; i++) {
3660 v->mb_type[0][s->block_index[i]] = 0;
3661 s->dc_val[0][s->block_index[i]] = 0;
3663 for (i = 0; i < 4; i++) {
3664 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3665 vc1_mc_4mv_luma(v, i, 0);
3667 vc1_mc_4mv_chroma(v, 0);
3668 s->current_picture.f.qscale_table[mb_pos] = 0;
3672 v->cbp[s->mb_x] = block_cbp;
3673 v->ttblk[s->mb_x] = block_tt;
3674 v->is_intra[s->mb_x] = block_intra;
3679 /* Decode one macroblock in an interlaced frame p picture */
3681 static int vc1_decode_p_mb_intfr(VC1Context *v)
3683 MpegEncContext *s = &v->s;
3684 GetBitContext *gb = &s->gb;
3686 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3687 int cbp = 0; /* cbp decoding stuff */
3688 int mqdiff, mquant; /* MB quantization */
3689 int ttmb = v->ttfrm; /* MB Transform type */
3691 int mb_has_coeffs = 1; /* last_flag */
3692 int dmv_x, dmv_y; /* Differential MV components */
3693 int val; /* temp value */
3694 int first_block = 1;
3696 int skipped, fourmv = 0, twomv = 0;
3697 int block_cbp = 0, pat, block_tt = 0;
3698 int idx_mbmode = 0, mvbp;
3699 int stride_y, fieldtx;
3701 mquant = v->pq; /* Loosy initialization */
3704 skipped = get_bits1(gb);
3706 skipped = v->s.mbskip_table[mb_pos];
3708 if (v->fourmvswitch)
3709 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3711 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3712 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3713 /* store the motion vector type in a flag (useful later) */
3714 case MV_PMODE_INTFR_4MV:
3716 v->blk_mv_type[s->block_index[0]] = 0;
3717 v->blk_mv_type[s->block_index[1]] = 0;
3718 v->blk_mv_type[s->block_index[2]] = 0;
3719 v->blk_mv_type[s->block_index[3]] = 0;
3721 case MV_PMODE_INTFR_4MV_FIELD:
3723 v->blk_mv_type[s->block_index[0]] = 1;
3724 v->blk_mv_type[s->block_index[1]] = 1;
3725 v->blk_mv_type[s->block_index[2]] = 1;
3726 v->blk_mv_type[s->block_index[3]] = 1;
3728 case MV_PMODE_INTFR_2MV_FIELD:
3730 v->blk_mv_type[s->block_index[0]] = 1;
3731 v->blk_mv_type[s->block_index[1]] = 1;
3732 v->blk_mv_type[s->block_index[2]] = 1;
3733 v->blk_mv_type[s->block_index[3]] = 1;
3735 case MV_PMODE_INTFR_1MV:
3736 v->blk_mv_type[s->block_index[0]] = 0;
3737 v->blk_mv_type[s->block_index[1]] = 0;
3738 v->blk_mv_type[s->block_index[2]] = 0;
3739 v->blk_mv_type[s->block_index[3]] = 0;
3742 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3743 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3744 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3745 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
3746 s->mb_intra = v->is_intra[s->mb_x] = 1;
3747 for (i = 0; i < 6; i++)
3748 v->mb_type[0][s->block_index[i]] = 1;
3749 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3750 mb_has_coeffs = get_bits1(gb);
3752 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3753 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3755 s->current_picture.f.qscale_table[mb_pos] = mquant;
3756 /* Set DC scale - y and c use the same (not sure if necessary here) */
3757 s->y_dc_scale = s->y_dc_scale_table[mquant];
3758 s->c_dc_scale = s->c_dc_scale_table[mquant];
3760 for (i = 0; i < 6; i++) {
3761 s->dc_val[0][s->block_index[i]] = 0;
3763 val = ((cbp >> (5 - i)) & 1);
3764 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3765 v->a_avail = v->c_avail = 0;
3766 if (i == 2 || i == 3 || !s->first_slice_line)
3767 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3768 if (i == 1 || i == 3 || s->mb_x)
3769 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3771 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3772 (i & 4) ? v->codingset2 : v->codingset);
3773 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3774 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3776 stride_y = s->linesize << fieldtx;
3777 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3779 stride_y = s->uvlinesize;
3782 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3786 } else { // inter MB
3787 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3789 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3790 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3791 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3793 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3794 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3795 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3798 s->mb_intra = v->is_intra[s->mb_x] = 0;
3799 for (i = 0; i < 6; i++)
3800 v->mb_type[0][s->block_index[i]] = 0;
3801 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3802 /* for all motion vector read MVDATA and motion compensate each block */
3806 for (i = 0; i < 6; i++) {
3809 val = ((mvbp >> (3 - i)) & 1);
3811 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3813 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3814 vc1_mc_4mv_luma(v, i, 0);
3815 } else if (i == 4) {
3816 vc1_mc_4mv_chroma4(v);
3823 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3825 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3826 vc1_mc_4mv_luma(v, 0, 0);
3827 vc1_mc_4mv_luma(v, 1, 0);
3830 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3832 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3833 vc1_mc_4mv_luma(v, 2, 0);
3834 vc1_mc_4mv_luma(v, 3, 0);
3835 vc1_mc_4mv_chroma4(v);
3837 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3840 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3842 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3846 GET_MQUANT(); // p. 227
3847 s->current_picture.f.qscale_table[mb_pos] = mquant;
3848 if (!v->ttmbf && cbp)
3849 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3850 for (i = 0; i < 6; i++) {
3851 s->dc_val[0][s->block_index[i]] = 0;
3853 val = ((cbp >> (5 - i)) & 1);
3855 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3857 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3859 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3860 first_block, s->dest[dst_idx] + off,
3861 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3862 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3863 block_cbp |= pat << (i << 2);
3864 if (!v->ttmbf && ttmb < 8)
3871 s->mb_intra = v->is_intra[s->mb_x] = 0;
3872 for (i = 0; i < 6; i++) {
3873 v->mb_type[0][s->block_index[i]] = 0;
3874 s->dc_val[0][s->block_index[i]] = 0;
3876 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3877 s->current_picture.f.qscale_table[mb_pos] = 0;
3878 v->blk_mv_type[s->block_index[0]] = 0;
3879 v->blk_mv_type[s->block_index[1]] = 0;
3880 v->blk_mv_type[s->block_index[2]] = 0;
3881 v->blk_mv_type[s->block_index[3]] = 0;
3882 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3885 if (s->mb_x == s->mb_width - 1)
3886 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3890 static int vc1_decode_p_mb_intfi(VC1Context *v)
3892 MpegEncContext *s = &v->s;
3893 GetBitContext *gb = &s->gb;
3895 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3896 int cbp = 0; /* cbp decoding stuff */
3897 int mqdiff, mquant; /* MB quantization */
3898 int ttmb = v->ttfrm; /* MB Transform type */
3900 int mb_has_coeffs = 1; /* last_flag */
3901 int dmv_x, dmv_y; /* Differential MV components */
3902 int val; /* temp values */
3903 int first_block = 1;
3906 int block_cbp = 0, pat, block_tt = 0;
3909 mquant = v->pq; /* Loosy initialization */
3911 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3912 if (idx_mbmode <= 1) { // intra MB
3913 s->mb_intra = v->is_intra[s->mb_x] = 1;
3914 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3915 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3916 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3918 s->current_picture.f.qscale_table[mb_pos] = mquant;
3919 /* Set DC scale - y and c use the same (not sure if necessary here) */
3920 s->y_dc_scale = s->y_dc_scale_table[mquant];
3921 s->c_dc_scale = s->c_dc_scale_table[mquant];
3922 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3923 mb_has_coeffs = idx_mbmode & 1;
3925 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3927 for (i = 0; i < 6; i++) {
3928 s->dc_val[0][s->block_index[i]] = 0;
3929 v->mb_type[0][s->block_index[i]] = 1;
3931 val = ((cbp >> (5 - i)) & 1);
3932 v->a_avail = v->c_avail = 0;
3933 if (i == 2 || i == 3 || !s->first_slice_line)
3934 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3935 if (i == 1 || i == 3 || s->mb_x)
3936 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3938 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3939 (i & 4) ? v->codingset2 : v->codingset);
3940 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3942 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3943 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3944 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
3945 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
3946 // TODO: loop filter
3949 s->mb_intra = v->is_intra[s->mb_x] = 0;
3950 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3951 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3952 if (idx_mbmode <= 5) { // 1-MV
3954 if (idx_mbmode & 1) {
3955 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3957 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3959 mb_has_coeffs = !(idx_mbmode & 2);
3961 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3962 for (i = 0; i < 6; i++) {
3964 dmv_x = dmv_y = pred_flag = 0;
3965 val = ((v->fourmvbp >> (3 - i)) & 1);
3967 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3969 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3970 vc1_mc_4mv_luma(v, i, 0);
3972 vc1_mc_4mv_chroma(v, 0);
3974 mb_has_coeffs = idx_mbmode & 1;
3977 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3981 s->current_picture.f.qscale_table[mb_pos] = mquant;
3982 if (!v->ttmbf && cbp) {
3983 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3986 for (i = 0; i < 6; i++) {
3987 s->dc_val[0][s->block_index[i]] = 0;
3989 val = ((cbp >> (5 - i)) & 1);
3990 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
3991 if (v->cur_field_type)
3992 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
3994 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3995 first_block, s->dest[dst_idx] + off,
3996 (i & 4) ? s->uvlinesize : s->linesize,
3997 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3999 block_cbp |= pat << (i << 2);
4000 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4005 if (s->mb_x == s->mb_width - 1)
4006 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4010 /** Decode one B-frame MB (in Main profile)
4012 static void vc1_decode_b_mb(VC1Context *v)
4014 MpegEncContext *s = &v->s;
4015 GetBitContext *gb = &s->gb;
4017 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4018 int cbp = 0; /* cbp decoding stuff */
4019 int mqdiff, mquant; /* MB quantization */
4020 int ttmb = v->ttfrm; /* MB Transform type */
4021 int mb_has_coeffs = 0; /* last_flag */
4022 int index, index1; /* LUT indexes */
4023 int val, sign; /* temp values */
4024 int first_block = 1;
4026 int skipped, direct;
4027 int dmv_x[2], dmv_y[2];
4028 int bmvtype = BMV_TYPE_BACKWARD;
4030 mquant = v->pq; /* lossy initialization */
4034 direct = get_bits1(gb);
4036 direct = v->direct_mb_plane[mb_pos];
4038 skipped = get_bits1(gb);
4040 skipped = v->s.mbskip_table[mb_pos];
4042 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4043 for (i = 0; i < 6; i++) {
4044 v->mb_type[0][s->block_index[i]] = 0;
4045 s->dc_val[0][s->block_index[i]] = 0;
4047 s->current_picture.f.qscale_table[mb_pos] = 0;
4051 GET_MVDATA(dmv_x[0], dmv_y[0]);
4052 dmv_x[1] = dmv_x[0];
4053 dmv_y[1] = dmv_y[0];
4055 if (skipped || !s->mb_intra) {
4056 bmvtype = decode012(gb);
4059 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4062 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4065 bmvtype = BMV_TYPE_INTERPOLATED;
4066 dmv_x[0] = dmv_y[0] = 0;
4070 for (i = 0; i < 6; i++)
4071 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4075 bmvtype = BMV_TYPE_INTERPOLATED;
4076 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4077 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4081 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4084 s->current_picture.f.qscale_table[mb_pos] = mquant;
4086 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4087 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4088 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4089 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4091 if (!mb_has_coeffs && !s->mb_intra) {
4092 /* no coded blocks - effectively skipped */
4093 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4094 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4097 if (s->mb_intra && !mb_has_coeffs) {
4099 s->current_picture.f.qscale_table[mb_pos] = mquant;
4100 s->ac_pred = get_bits1(gb);
4102 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4104 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4105 GET_MVDATA(dmv_x[0], dmv_y[0]);
4106 if (!mb_has_coeffs) {
4107 /* interpolated skipped block */
4108 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4109 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4113 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4115 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4118 s->ac_pred = get_bits1(gb);
4119 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4121 s->current_picture.f.qscale_table[mb_pos] = mquant;
4122 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4123 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4127 for (i = 0; i < 6; i++) {
4128 s->dc_val[0][s->block_index[i]] = 0;
4130 val = ((cbp >> (5 - i)) & 1);
4131 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4132 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4134 /* check if prediction blocks A and C are available */
4135 v->a_avail = v->c_avail = 0;
4136 if (i == 2 || i == 3 || !s->first_slice_line)
4137 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4138 if (i == 1 || i == 3 || s->mb_x)
4139 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4141 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4142 (i & 4) ? v->codingset2 : v->codingset);
4143 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4145 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4147 for (j = 0; j < 64; j++)
4148 s->block[i][j] <<= 1;
4149 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4151 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4152 first_block, s->dest[dst_idx] + off,
4153 (i & 4) ? s->uvlinesize : s->linesize,
4154 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4155 if (!v->ttmbf && ttmb < 8)
4162 /** Decode one B-frame MB (in interlaced field B picture)
4164 static void vc1_decode_b_mb_intfi(VC1Context *v)
4166 MpegEncContext *s = &v->s;
4167 GetBitContext *gb = &s->gb;
4169 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4170 int cbp = 0; /* cbp decoding stuff */
4171 int mqdiff, mquant; /* MB quantization */
4172 int ttmb = v->ttfrm; /* MB Transform type */
4173 int mb_has_coeffs = 0; /* last_flag */
4174 int val; /* temp value */
4175 int first_block = 1;
4178 int dmv_x[2], dmv_y[2], pred_flag[2];
4179 int bmvtype = BMV_TYPE_BACKWARD;
4180 int idx_mbmode, interpmvp;
4182 mquant = v->pq; /* Loosy initialization */
4185 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4186 if (idx_mbmode <= 1) { // intra MB
4187 s->mb_intra = v->is_intra[s->mb_x] = 1;
4188 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4189 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4190 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4192 s->current_picture.f.qscale_table[mb_pos] = mquant;
4193 /* Set DC scale - y and c use the same (not sure if necessary here) */
4194 s->y_dc_scale = s->y_dc_scale_table[mquant];
4195 s->c_dc_scale = s->c_dc_scale_table[mquant];
4196 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4197 mb_has_coeffs = idx_mbmode & 1;
4199 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4201 for (i = 0; i < 6; i++) {
4202 s->dc_val[0][s->block_index[i]] = 0;
4204 val = ((cbp >> (5 - i)) & 1);
4205 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4206 v->a_avail = v->c_avail = 0;
4207 if (i == 2 || i == 3 || !s->first_slice_line)
4208 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4209 if (i == 1 || i == 3 || s->mb_x)
4210 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4212 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4213 (i & 4) ? v->codingset2 : v->codingset);
4214 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4216 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4218 for (j = 0; j < 64; j++)
4219 s->block[i][j] <<= 1;
4220 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4221 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4222 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4223 // TODO: yet to perform loop filter
4226 s->mb_intra = v->is_intra[s->mb_x] = 0;
4227 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4228 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4230 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4232 fwd = v->forward_mb_plane[mb_pos];
4233 if (idx_mbmode <= 5) { // 1-MV
4234 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4235 pred_flag[0] = pred_flag[1] = 0;
4237 bmvtype = BMV_TYPE_FORWARD;
4239 bmvtype = decode012(gb);
4242 bmvtype = BMV_TYPE_BACKWARD;
4245 bmvtype = BMV_TYPE_DIRECT;
4248 bmvtype = BMV_TYPE_INTERPOLATED;
4249 interpmvp = get_bits1(gb);
4252 v->bmvtype = bmvtype;
4253 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4254 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4256 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4257 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4259 if (bmvtype == BMV_TYPE_DIRECT) {
4260 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4261 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4263 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4264 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4265 mb_has_coeffs = !(idx_mbmode & 2);
4268 bmvtype = BMV_TYPE_FORWARD;
4269 v->bmvtype = bmvtype;
4270 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4271 for (i = 0; i < 6; i++) {
4273 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4274 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4275 val = ((v->fourmvbp >> (3 - i)) & 1);
4277 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4278 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4279 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4281 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4282 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4284 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4286 mb_has_coeffs = idx_mbmode & 1;
4289 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4293 s->current_picture.f.qscale_table[mb_pos] = mquant;
4294 if (!v->ttmbf && cbp) {
4295 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4298 for (i = 0; i < 6; i++) {
4299 s->dc_val[0][s->block_index[i]] = 0;
4301 val = ((cbp >> (5 - i)) & 1);
4302 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4303 if (v->cur_field_type)
4304 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4306 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4307 first_block, s->dest[dst_idx] + off,
4308 (i & 4) ? s->uvlinesize : s->linesize,
4309 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4310 if (!v->ttmbf && ttmb < 8)
4318 /** Decode blocks of I-frame
4320 static void vc1_decode_i_blocks(VC1Context *v)
4323 MpegEncContext *s = &v->s;
4328 /* select codingmode used for VLC tables selection */
4329 switch (v->y_ac_table_index) {
4331 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4334 v->codingset = CS_HIGH_MOT_INTRA;
4337 v->codingset = CS_MID_RATE_INTRA;
4341 switch (v->c_ac_table_index) {
4343 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4346 v->codingset2 = CS_HIGH_MOT_INTER;
4349 v->codingset2 = CS_MID_RATE_INTER;
4353 /* Set DC scale - y and c use the same */
4354 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4355 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4358 s->mb_x = s->mb_y = 0;
4360 s->first_slice_line = 1;
4361 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4363 ff_init_block_index(s);
4364 for (; s->mb_x < s->mb_width; s->mb_x++) {
4366 ff_update_block_index(s);
4367 dst[0] = s->dest[0];
4368 dst[1] = dst[0] + 8;
4369 dst[2] = s->dest[0] + s->linesize * 8;
4370 dst[3] = dst[2] + 8;
4371 dst[4] = s->dest[1];
4372 dst[5] = s->dest[2];
4373 s->dsp.clear_blocks(s->block[0]);
4374 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4375 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
4376 s->current_picture.f.qscale_table[mb_pos] = v->pq;
4377 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4378 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4380 // do actual MB decoding and displaying
4381 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4382 v->s.ac_pred = get_bits1(&v->s.gb);
4384 for (k = 0; k < 6; k++) {
4385 val = ((cbp >> (5 - k)) & 1);
4388 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4392 cbp |= val << (5 - k);
4394 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4396 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4398 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4399 if (v->pq >= 9 && v->overlap) {
4401 for (j = 0; j < 64; j++)
4402 s->block[k][j] <<= 1;
4403 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4406 for (j = 0; j < 64; j++)
4407 s->block[k][j] = (s->block[k][j] - 64) << 1;
4408 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4412 if (v->pq >= 9 && v->overlap) {
4414 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4415 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4416 if (!(s->flags & CODEC_FLAG_GRAY)) {
4417 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4418 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4421 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4422 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4423 if (!s->first_slice_line) {
4424 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4425 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4426 if (!(s->flags & CODEC_FLAG_GRAY)) {
4427 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4428 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4431 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4432 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4434 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4436 if (get_bits_count(&s->gb) > v->bits) {
4437 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4438 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4439 get_bits_count(&s->gb), v->bits);
4443 if (!v->s.loop_filter)
4444 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4446 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4448 s->first_slice_line = 0;
4450 if (v->s.loop_filter)
4451 ff_draw_horiz_band(s, (s->mb_height - 1) * 16, 16);
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) {
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 static void 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 == 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;
4941 ysub[sprite] = ycoord & 0xFFFF;
4943 iplane = s->last_picture.f.data[plane];
4944 iline = s->last_picture.f.linesize[plane];
4946 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4947 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
4949 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + (yline + 1) * iline;
4951 if (sr_cache[sprite][0] != yline) {
4952 if (sr_cache[sprite][1] == yline) {
4953 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
4954 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
4956 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
4957 sr_cache[sprite][0] = yline;
4960 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4961 v->vc1dsp.sprite_h(v->sr_rows[sprite][1], iplane + (yline + 1) * iline, xoff[sprite], xadv[sprite], width);
4962 sr_cache[sprite][1] = yline + 1;
4964 src_h[sprite][0] = v->sr_rows[sprite][0];
4965 src_h[sprite][1] = v->sr_rows[sprite][1];
4969 if (!v->two_sprites) {
4971 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
4973 memcpy(dst, src_h[0][0], width);
4976 if (ysub[0] && ysub[1]) {
4977 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
4978 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
4979 } else if (ysub[0]) {
4980 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
4981 src_h[1][0], alpha, width);
4982 } else if (ysub[1]) {
4983 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
4984 src_h[0][0], (1<<16)-1-alpha, width);
4986 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
4992 for (i = 0; i < 2; i++) {
5002 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5004 MpegEncContext *s = &v->s;
5005 AVCodecContext *avctx = s->avctx;
5008 vc1_parse_sprites(v, gb, &sd);
5010 if (!s->current_picture.f.data[0]) {
5011 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5015 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5016 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5020 if (v->sprite_output_frame.data[0])
5021 avctx->release_buffer(avctx, &v->sprite_output_frame);
5023 v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5024 v->sprite_output_frame.reference = 0;
5025 if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
5026 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5030 vc1_draw_sprites(v, &sd);
5035 static void vc1_sprite_flush(AVCodecContext *avctx)
5037 VC1Context *v = avctx->priv_data;
5038 MpegEncContext *s = &v->s;
5039 AVFrame *f = &s->current_picture.f;
5042 /* Windows Media Image codecs have a convergence interval of two keyframes.
5043 Since we can't enforce it, clear to black the missing sprite. This is
5044 wrong but it looks better than doing nothing. */
5047 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5048 for (i = 0; i < v->sprite_height>>!!plane; i++)
5049 memset(f->data[plane] + i * f->linesize[plane],
5050 plane ? 128 : 0, f->linesize[plane]);
5055 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
5057 MpegEncContext *s = &v->s;
5060 /* Allocate mb bitplanes */
5061 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5062 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5063 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5064 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5065 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5066 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5068 v->n_allocated_blks = s->mb_width + 2;
5069 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5070 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5071 v->cbp = v->cbp_base + s->mb_stride;
5072 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5073 v->ttblk = v->ttblk_base + s->mb_stride;
5074 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5075 v->is_intra = v->is_intra_base + s->mb_stride;
5076 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5077 v->luma_mv = v->luma_mv_base + s->mb_stride;
5079 /* allocate block type info in that way so it could be used with s->block_index[] */
5080 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5081 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5082 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5083 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5085 /* allocate memory to store block level MV info */
5086 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5087 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5088 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5089 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5090 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5091 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5092 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
5093 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);
5094 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5095 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5096 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);
5098 /* Init coded blocks info */
5099 if (v->profile == PROFILE_ADVANCED) {
5100 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5102 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5106 ff_intrax8_common_init(&v->x8,s);
5108 if (s->avctx->codec_id == CODEC_ID_WMV3IMAGE || s->avctx->codec_id == CODEC_ID_VC1IMAGE) {
5109 for (i = 0; i < 4; i++)
5110 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5113 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5114 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5121 /** Initialize a VC1/WMV3 decoder
5122 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5123 * @todo TODO: Decypher remaining bits in extra_data
5125 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5127 VC1Context *v = avctx->priv_data;
5128 MpegEncContext *s = &v->s;
5132 /* save the container output size for WMImage */
5133 v->output_width = avctx->width;
5134 v->output_height = avctx->height;
5136 if (!avctx->extradata_size || !avctx->extradata)
5138 if (!(avctx->flags & CODEC_FLAG_GRAY))
5139 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5141 avctx->pix_fmt = PIX_FMT_GRAY8;
5142 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5144 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5145 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5147 if (avctx->idct_algo == FF_IDCT_AUTO) {
5148 avctx->idct_algo = FF_IDCT_WMV2;
5151 if (ff_vc1_init_common(v) < 0)
5153 ff_vc1dsp_init(&v->vc1dsp);
5155 if (avctx->codec_id == CODEC_ID_WMV3 || avctx->codec_id == CODEC_ID_WMV3IMAGE) {
5158 // looks like WMV3 has a sequence header stored in the extradata
5159 // advanced sequence header may be before the first frame
5160 // the last byte of the extradata is a version number, 1 for the
5161 // samples we can decode
5163 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5165 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5168 count = avctx->extradata_size*8 - get_bits_count(&gb);
5170 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5171 count, get_bits(&gb, count));
5172 } else if (count < 0) {
5173 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5175 } else { // VC1/WVC1/WVP2
5176 const uint8_t *start = avctx->extradata;
5177 uint8_t *end = avctx->extradata + avctx->extradata_size;
5178 const uint8_t *next;
5179 int size, buf2_size;
5180 uint8_t *buf2 = NULL;
5181 int seq_initialized = 0, ep_initialized = 0;
5183 if (avctx->extradata_size < 16) {
5184 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5188 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5189 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5191 for (; next < end; start = next) {
5192 next = find_next_marker(start + 4, end);
5193 size = next - start - 4;
5196 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5197 init_get_bits(&gb, buf2, buf2_size * 8);
5198 switch (AV_RB32(start)) {
5199 case VC1_CODE_SEQHDR:
5200 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5204 seq_initialized = 1;
5206 case VC1_CODE_ENTRYPOINT:
5207 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5216 if (!seq_initialized || !ep_initialized) {
5217 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5220 v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
5223 avctx->profile = v->profile;
5224 if (v->profile == PROFILE_ADVANCED)
5225 avctx->level = v->level;
5227 avctx->has_b_frames = !!avctx->max_b_frames;
5229 s->mb_width = (avctx->coded_width + 15) >> 4;
5230 s->mb_height = (avctx->coded_height + 15) >> 4;
5232 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5233 for (i = 0; i < 64; i++) {
5234 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5235 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5236 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5237 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5238 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5239 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5244 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5249 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5250 v->sprite_width = avctx->coded_width;
5251 v->sprite_height = avctx->coded_height;
5253 avctx->coded_width = avctx->width = v->output_width;
5254 avctx->coded_height = avctx->height = v->output_height;
5256 // prevent 16.16 overflows
5257 if (v->sprite_width > 1 << 14 ||
5258 v->sprite_height > 1 << 14 ||
5259 v->output_width > 1 << 14 ||
5260 v->output_height > 1 << 14) return -1;
5265 /** Close a VC1/WMV3 decoder
5266 * @warning Initial try at using MpegEncContext stuff
5268 static av_cold int vc1_decode_end(AVCodecContext *avctx)
5270 VC1Context *v = avctx->priv_data;
5273 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
5274 && v->sprite_output_frame.data[0])
5275 avctx->release_buffer(avctx, &v->sprite_output_frame);
5276 for (i = 0; i < 4; i++)
5277 av_freep(&v->sr_rows[i >> 1][i & 1]);
5278 av_freep(&v->hrd_rate);
5279 av_freep(&v->hrd_buffer);
5280 ff_MPV_common_end(&v->s);
5281 av_freep(&v->mv_type_mb_plane);
5282 av_freep(&v->direct_mb_plane);
5283 av_freep(&v->forward_mb_plane);
5284 av_freep(&v->fieldtx_plane);
5285 av_freep(&v->acpred_plane);
5286 av_freep(&v->over_flags_plane);
5287 av_freep(&v->mb_type_base);
5288 av_freep(&v->blk_mv_type_base);
5289 av_freep(&v->mv_f_base);
5290 av_freep(&v->mv_f_last_base);
5291 av_freep(&v->mv_f_next_base);
5292 av_freep(&v->block);
5293 av_freep(&v->cbp_base);
5294 av_freep(&v->ttblk_base);
5295 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5296 av_freep(&v->luma_mv_base);
5297 ff_intrax8_common_end(&v->x8);
5302 /** Decode a VC1/WMV3 frame
5303 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5305 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5306 int *data_size, AVPacket *avpkt)
5308 const uint8_t *buf = avpkt->data;
5309 int buf_size = avpkt->size, n_slices = 0, i;
5310 VC1Context *v = avctx->priv_data;
5311 MpegEncContext *s = &v->s;
5312 AVFrame *pict = data;
5313 uint8_t *buf2 = NULL;
5314 const uint8_t *buf_start = buf;
5315 int mb_height, n_slices1;
5320 } *slices = NULL, *tmp;
5322 /* no supplementary picture */
5323 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5324 /* special case for last picture */
5325 if (s->low_delay == 0 && s->next_picture_ptr) {
5326 *pict = s->next_picture_ptr->f;
5327 s->next_picture_ptr = NULL;
5329 *data_size = sizeof(AVFrame);
5335 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5336 if (v->profile < PROFILE_ADVANCED)
5337 avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
5339 avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
5342 //for advanced profile we may need to parse and unescape data
5343 if (avctx->codec_id == CODEC_ID_VC1 || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5345 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5347 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5348 const uint8_t *start, *end, *next;
5352 for (start = buf, end = buf + buf_size; next < end; start = next) {
5353 next = find_next_marker(start + 4, end);
5354 size = next - start - 4;
5355 if (size <= 0) continue;
5356 switch (AV_RB32(start)) {
5357 case VC1_CODE_FRAME:
5358 if (avctx->hwaccel ||
5359 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5361 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5363 case VC1_CODE_FIELD: {
5365 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5368 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5369 if (!slices[n_slices].buf)
5371 buf_size3 = vc1_unescape_buffer(start + 4, size,
5372 slices[n_slices].buf);
5373 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5375 /* assuming that the field marker is at the exact middle,
5376 hope it's correct */
5377 slices[n_slices].mby_start = s->mb_height >> 1;
5378 n_slices1 = n_slices - 1; // index of the last slice of the first field
5382 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5383 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5384 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5385 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5387 case VC1_CODE_SLICE: {
5389 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5392 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5393 if (!slices[n_slices].buf)
5395 buf_size3 = vc1_unescape_buffer(start + 4, size,
5396 slices[n_slices].buf);
5397 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5399 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5405 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5406 const uint8_t *divider;
5409 divider = find_next_marker(buf, buf + buf_size);
5410 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5411 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5413 } else { // found field marker, unescape second field
5414 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5418 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5419 if (!slices[n_slices].buf)
5421 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5422 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5424 slices[n_slices].mby_start = s->mb_height >> 1;
5425 n_slices1 = n_slices - 1;
5428 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5430 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5432 init_get_bits(&s->gb, buf2, buf_size2*8);
5434 init_get_bits(&s->gb, buf, buf_size*8);
5436 if (v->res_sprite) {
5437 v->new_sprite = !get_bits1(&s->gb);
5438 v->two_sprites = get_bits1(&s->gb);
5439 /* res_sprite means a Windows Media Image stream, CODEC_ID_*IMAGE means
5440 we're using the sprite compositor. These are intentionally kept separate
5441 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5442 the vc1 one for WVP2 */
5443 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5444 if (v->new_sprite) {
5445 // switch AVCodecContext parameters to those of the sprites
5446 avctx->width = avctx->coded_width = v->sprite_width;
5447 avctx->height = avctx->coded_height = v->sprite_height;
5454 if (s->context_initialized &&
5455 (s->width != avctx->coded_width ||
5456 s->height != avctx->coded_height)) {
5457 vc1_decode_end(avctx);
5460 if (!s->context_initialized) {
5461 if (ff_msmpeg4_decode_init(avctx) < 0 || vc1_decode_init_alloc_tables(v) < 0)
5464 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5466 if (v->profile == PROFILE_ADVANCED) {
5467 s->h_edge_pos = avctx->coded_width;
5468 s->v_edge_pos = avctx->coded_height;
5472 /* We need to set current_picture_ptr before reading the header,
5473 * otherwise we cannot store anything in there. */
5474 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5475 int i = ff_find_unused_picture(s, 0);
5478 s->current_picture_ptr = &s->picture[i];
5481 // do parse frame header
5482 v->pic_header_flag = 0;
5483 if (v->profile < PROFILE_ADVANCED) {
5484 if (ff_vc1_parse_frame_header(v, &s->gb) == -1) {
5488 if (ff_vc1_parse_frame_header_adv(v, &s->gb) == -1) {
5493 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
5494 && s->pict_type != AV_PICTURE_TYPE_I) {
5495 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5499 // process pulldown flags
5500 s->current_picture_ptr->f.repeat_pict = 0;
5501 // Pulldown flags are only valid when 'broadcast' has been set.
5502 // So ticks_per_frame will be 2
5505 s->current_picture_ptr->f.repeat_pict = 1;
5506 } else if (v->rptfrm) {
5508 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5511 // for skipping the frame
5512 s->current_picture.f.pict_type = s->pict_type;
5513 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5515 /* skip B-frames if we don't have reference frames */
5516 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
5519 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5520 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5521 avctx->skip_frame >= AVDISCARD_ALL) {
5525 if (s->next_p_frame_damaged) {
5526 if (s->pict_type == AV_PICTURE_TYPE_B)
5529 s->next_p_frame_damaged = 0;
5532 if (ff_MPV_frame_start(s, avctx) < 0) {
5536 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5537 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5539 if ((CONFIG_VC1_VDPAU_DECODER)
5540 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5541 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5542 else if (avctx->hwaccel) {
5543 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
5545 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5547 if (avctx->hwaccel->end_frame(avctx) < 0)
5550 ff_er_frame_start(s);
5552 v->bits = buf_size * 8;
5553 if (v->field_mode) {
5555 s->current_picture.f.linesize[0] <<= 1;
5556 s->current_picture.f.linesize[1] <<= 1;
5557 s->current_picture.f.linesize[2] <<= 1;
5559 s->uvlinesize <<= 1;
5560 tmp[0] = v->mv_f_last[0];
5561 tmp[1] = v->mv_f_last[1];
5562 v->mv_f_last[0] = v->mv_f_next[0];
5563 v->mv_f_last[1] = v->mv_f_next[1];
5564 v->mv_f_next[0] = v->mv_f[0];
5565 v->mv_f_next[1] = v->mv_f[1];
5566 v->mv_f[0] = tmp[0];
5567 v->mv_f[1] = tmp[1];
5569 mb_height = s->mb_height >> v->field_mode;
5570 for (i = 0; i <= n_slices; i++) {
5571 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5572 v->second_field = 1;
5573 v->blocks_off = s->mb_width * s->mb_height << 1;
5574 v->mb_off = s->mb_stride * s->mb_height >> 1;
5576 v->second_field = 0;
5581 v->pic_header_flag = 0;
5582 if (v->field_mode && i == n_slices1 + 2)
5583 ff_vc1_parse_frame_header_adv(v, &s->gb);
5584 else if (get_bits1(&s->gb)) {
5585 v->pic_header_flag = 1;
5586 ff_vc1_parse_frame_header_adv(v, &s->gb);
5589 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5590 if (!v->field_mode || v->second_field)
5591 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5593 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5594 vc1_decode_blocks(v);
5596 s->gb = slices[i].gb;
5598 if (v->field_mode) {
5599 v->second_field = 0;
5600 if (s->pict_type == AV_PICTURE_TYPE_B) {
5601 memcpy(v->mv_f_base, v->mv_f_next_base,
5602 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5604 s->current_picture.f.linesize[0] >>= 1;
5605 s->current_picture.f.linesize[1] >>= 1;
5606 s->current_picture.f.linesize[2] >>= 1;
5608 s->uvlinesize >>= 1;
5610 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
5611 // if (get_bits_count(&s->gb) > buf_size * 8)
5616 ff_MPV_frame_end(s);
5618 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5620 avctx->width = avctx->coded_width = v->output_width;
5621 avctx->height = avctx->coded_height = v->output_height;
5622 if (avctx->skip_frame >= AVDISCARD_NONREF)
5624 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5625 if (vc1_decode_sprites(v, &s->gb))
5628 *pict = v->sprite_output_frame;
5629 *data_size = sizeof(AVFrame);
5631 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5632 *pict = s->current_picture_ptr->f;
5633 } else if (s->last_picture_ptr != NULL) {
5634 *pict = s->last_picture_ptr->f;
5636 if (s->last_picture_ptr || s->low_delay) {
5637 *data_size = sizeof(AVFrame);
5638 ff_print_debug_info(s, pict);
5644 for (i = 0; i < n_slices; i++)
5645 av_free(slices[i].buf);
5651 for (i = 0; i < n_slices; i++)
5652 av_free(slices[i].buf);
5658 static const AVProfile profiles[] = {
5659 { FF_PROFILE_VC1_SIMPLE, "Simple" },
5660 { FF_PROFILE_VC1_MAIN, "Main" },
5661 { FF_PROFILE_VC1_COMPLEX, "Complex" },
5662 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5663 { FF_PROFILE_UNKNOWN },
5666 AVCodec ff_vc1_decoder = {
5668 .type = AVMEDIA_TYPE_VIDEO,
5670 .priv_data_size = sizeof(VC1Context),
5671 .init = vc1_decode_init,
5672 .close = vc1_decode_end,
5673 .decode = vc1_decode_frame,
5674 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5675 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5676 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5677 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5680 #if CONFIG_WMV3_DECODER
5681 AVCodec ff_wmv3_decoder = {
5683 .type = AVMEDIA_TYPE_VIDEO,
5684 .id = CODEC_ID_WMV3,
5685 .priv_data_size = sizeof(VC1Context),
5686 .init = vc1_decode_init,
5687 .close = vc1_decode_end,
5688 .decode = vc1_decode_frame,
5689 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5690 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5691 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5692 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5696 #if CONFIG_WMV3_VDPAU_DECODER
5697 AVCodec ff_wmv3_vdpau_decoder = {
5698 .name = "wmv3_vdpau",
5699 .type = AVMEDIA_TYPE_VIDEO,
5700 .id = CODEC_ID_WMV3,
5701 .priv_data_size = sizeof(VC1Context),
5702 .init = vc1_decode_init,
5703 .close = vc1_decode_end,
5704 .decode = vc1_decode_frame,
5705 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5706 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5707 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE },
5708 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5712 #if CONFIG_VC1_VDPAU_DECODER
5713 AVCodec ff_vc1_vdpau_decoder = {
5714 .name = "vc1_vdpau",
5715 .type = AVMEDIA_TYPE_VIDEO,
5717 .priv_data_size = sizeof(VC1Context),
5718 .init = vc1_decode_init,
5719 .close = vc1_decode_end,
5720 .decode = vc1_decode_frame,
5721 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5722 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5723 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_VDPAU_VC1, PIX_FMT_NONE },
5724 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5728 #if CONFIG_WMV3IMAGE_DECODER
5729 AVCodec ff_wmv3image_decoder = {
5730 .name = "wmv3image",
5731 .type = AVMEDIA_TYPE_VIDEO,
5732 .id = CODEC_ID_WMV3IMAGE,
5733 .priv_data_size = sizeof(VC1Context),
5734 .init = vc1_decode_init,
5735 .close = vc1_decode_end,
5736 .decode = vc1_decode_frame,
5737 .capabilities = CODEC_CAP_DR1,
5738 .flush = vc1_sprite_flush,
5739 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5740 .pix_fmts = ff_pixfmt_list_420
5744 #if CONFIG_VC1IMAGE_DECODER
5745 AVCodec ff_vc1image_decoder = {
5747 .type = AVMEDIA_TYPE_VIDEO,
5748 .id = CODEC_ID_VC1IMAGE,
5749 .priv_data_size = sizeof(VC1Context),
5750 .init = vc1_decode_init,
5751 .close = vc1_decode_end,
5752 .decode = vc1_decode_frame,
5753 .capabilities = CODEC_CAP_DR1,
5754 .flush = vc1_sprite_flush,
5755 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5756 .pix_fmts = ff_pixfmt_list_420