2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
31 #include "error_resilience.h"
32 #include "mpegvideo.h"
34 #include "h264chroma.h"
37 #include "vc1acdata.h"
38 #include "msmpeg4data.h"
41 #include "vdpau_internal.h"
42 #include "libavutil/avassert.h"
47 #define MB_INTRA_VLC_BITS 9
51 // offset tables for interlaced picture MVDATA decoding
52 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
53 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
55 /***********************************************************************/
57 * @name VC-1 Bitplane decoding
75 /** @} */ //imode defines
77 static void init_block_index(VC1Context *v)
79 MpegEncContext *s = &v->s;
80 ff_init_block_index(s);
81 if (v->field_mode && !(v->second_field ^ v->tff)) {
82 s->dest[0] += s->current_picture_ptr->f.linesize[0];
83 s->dest[1] += s->current_picture_ptr->f.linesize[1];
84 s->dest[2] += s->current_picture_ptr->f.linesize[2];
88 /** @} */ //Bitplane group
90 static void vc1_put_signed_blocks_clamped(VC1Context *v)
92 MpegEncContext *s = &v->s;
93 int topleft_mb_pos, top_mb_pos;
94 int stride_y, fieldtx = 0;
97 /* The put pixels loop is always one MB row behind the decoding loop,
98 * because we can only put pixels when overlap filtering is done, and
99 * for filtering of the bottom edge of a MB, we need the next MB row
101 * Within the row, the put pixels loop is also one MB col behind the
102 * decoding loop. The reason for this is again, because for filtering
103 * of the right MB edge, we need the next MB present. */
104 if (!s->first_slice_line) {
106 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
107 if (v->fcm == ILACE_FRAME)
108 fieldtx = v->fieldtx_plane[topleft_mb_pos];
109 stride_y = s->linesize << fieldtx;
110 v_dist = (16 - fieldtx) >> (fieldtx == 0);
111 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
112 s->dest[0] - 16 * s->linesize - 16,
114 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
115 s->dest[0] - 16 * s->linesize - 8,
117 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
118 s->dest[0] - v_dist * s->linesize - 16,
120 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
121 s->dest[0] - v_dist * s->linesize - 8,
123 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
124 s->dest[1] - 8 * s->uvlinesize - 8,
126 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
127 s->dest[2] - 8 * s->uvlinesize - 8,
130 if (s->mb_x == s->mb_width - 1) {
131 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
132 if (v->fcm == ILACE_FRAME)
133 fieldtx = v->fieldtx_plane[top_mb_pos];
134 stride_y = s->linesize << fieldtx;
135 v_dist = fieldtx ? 15 : 8;
136 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
137 s->dest[0] - 16 * s->linesize,
139 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
140 s->dest[0] - 16 * s->linesize + 8,
142 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
143 s->dest[0] - v_dist * s->linesize,
145 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
146 s->dest[0] - v_dist * s->linesize + 8,
148 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
149 s->dest[1] - 8 * s->uvlinesize,
151 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
152 s->dest[2] - 8 * s->uvlinesize,
157 #define inc_blk_idx(idx) do { \
159 if (idx >= v->n_allocated_blks) \
163 inc_blk_idx(v->topleft_blk_idx);
164 inc_blk_idx(v->top_blk_idx);
165 inc_blk_idx(v->left_blk_idx);
166 inc_blk_idx(v->cur_blk_idx);
169 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
171 MpegEncContext *s = &v->s;
173 if (!s->first_slice_line) {
174 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
176 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
177 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
178 for (j = 0; j < 2; j++) {
179 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
181 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
184 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
186 if (s->mb_y == s->end_mb_y - 1) {
188 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
189 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
190 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
192 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
196 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
198 MpegEncContext *s = &v->s;
201 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
202 * means it runs two rows/cols behind the decoding loop. */
203 if (!s->first_slice_line) {
205 if (s->mb_y >= s->start_mb_y + 2) {
206 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
209 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
210 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
211 for (j = 0; j < 2; j++) {
212 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
214 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
218 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
221 if (s->mb_x == s->mb_width - 1) {
222 if (s->mb_y >= s->start_mb_y + 2) {
223 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
226 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
227 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
228 for (j = 0; j < 2; j++) {
229 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
231 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
235 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
238 if (s->mb_y == s->end_mb_y) {
241 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
242 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
244 for (j = 0; j < 2; j++) {
245 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
250 if (s->mb_x == s->mb_width - 1) {
252 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
253 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
255 for (j = 0; j < 2; j++) {
256 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
264 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
266 MpegEncContext *s = &v->s;
269 if (v->condover == CONDOVER_NONE)
272 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
274 /* Within a MB, the horizontal overlap always runs before the vertical.
275 * To accomplish that, we run the H on left and internal borders of the
276 * currently decoded MB. Then, we wait for the next overlap iteration
277 * to do H overlap on the right edge of this MB, before moving over and
278 * running the V overlap. Therefore, the V overlap makes us trail by one
279 * MB col and the H overlap filter makes us trail by one MB row. This
280 * is reflected in the time at which we run the put_pixels loop. */
281 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
282 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
283 v->over_flags_plane[mb_pos - 1])) {
284 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
285 v->block[v->cur_blk_idx][0]);
286 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
287 v->block[v->cur_blk_idx][2]);
288 if (!(s->flags & CODEC_FLAG_GRAY)) {
289 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
290 v->block[v->cur_blk_idx][4]);
291 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
292 v->block[v->cur_blk_idx][5]);
295 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
296 v->block[v->cur_blk_idx][1]);
297 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
298 v->block[v->cur_blk_idx][3]);
300 if (s->mb_x == s->mb_width - 1) {
301 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
302 v->over_flags_plane[mb_pos - s->mb_stride])) {
303 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
304 v->block[v->cur_blk_idx][0]);
305 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
306 v->block[v->cur_blk_idx][1]);
307 if (!(s->flags & CODEC_FLAG_GRAY)) {
308 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
309 v->block[v->cur_blk_idx][4]);
310 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
311 v->block[v->cur_blk_idx][5]);
314 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
315 v->block[v->cur_blk_idx][2]);
316 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
317 v->block[v->cur_blk_idx][3]);
320 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
321 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
322 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
323 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
324 v->block[v->left_blk_idx][0]);
325 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
326 v->block[v->left_blk_idx][1]);
327 if (!(s->flags & CODEC_FLAG_GRAY)) {
328 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
329 v->block[v->left_blk_idx][4]);
330 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
331 v->block[v->left_blk_idx][5]);
334 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
335 v->block[v->left_blk_idx][2]);
336 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
337 v->block[v->left_blk_idx][3]);
341 /** Do motion compensation over 1 macroblock
342 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
344 static void vc1_mc_1mv(VC1Context *v, int dir)
346 MpegEncContext *s = &v->s;
347 H264ChromaContext *h264chroma = &v->h264chroma;
348 uint8_t *srcY, *srcU, *srcV;
349 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
350 int v_edge_pos = s->v_edge_pos >> v->field_mode;
352 uint8_t (*luty)[256], (*lutuv)[256];
355 if ((!v->field_mode ||
356 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
357 !v->s.last_picture.f.data[0])
360 mx = s->mv[dir][0][0];
361 my = s->mv[dir][0][1];
363 // store motion vectors for further use in B frames
364 if (s->pict_type == AV_PICTURE_TYPE_P) {
365 for (i = 0; i < 4; i++) {
366 s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = mx;
367 s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = my;
371 uvmx = (mx + ((mx & 3) == 3)) >> 1;
372 uvmy = (my + ((my & 3) == 3)) >> 1;
373 v->luma_mv[s->mb_x][0] = uvmx;
374 v->luma_mv[s->mb_x][1] = uvmy;
377 v->cur_field_type != v->ref_field_type[dir]) {
378 my = my - 2 + 4 * v->cur_field_type;
379 uvmy = uvmy - 2 + 4 * v->cur_field_type;
382 // fastuvmc shall be ignored for interlaced frame picture
383 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
384 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
385 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
388 if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
389 srcY = s->current_picture.f.data[0];
390 srcU = s->current_picture.f.data[1];
391 srcV = s->current_picture.f.data[2];
393 lutuv = v->curr_lutuv;
394 use_ic = v->curr_use_ic;
396 srcY = s->last_picture.f.data[0];
397 srcU = s->last_picture.f.data[1];
398 srcV = s->last_picture.f.data[2];
400 lutuv = v->last_lutuv;
401 use_ic = v->last_use_ic;
404 srcY = s->next_picture.f.data[0];
405 srcU = s->next_picture.f.data[1];
406 srcV = s->next_picture.f.data[2];
408 lutuv = v->next_lutuv;
409 use_ic = v->next_use_ic;
412 if (!srcY || !srcU) {
413 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
417 src_x = s->mb_x * 16 + (mx >> 2);
418 src_y = s->mb_y * 16 + (my >> 2);
419 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
420 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
422 if (v->profile != PROFILE_ADVANCED) {
423 src_x = av_clip( src_x, -16, s->mb_width * 16);
424 src_y = av_clip( src_y, -16, s->mb_height * 16);
425 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
426 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
428 src_x = av_clip( src_x, -17, s->avctx->coded_width);
429 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
430 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
431 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
434 srcY += src_y * s->linesize + src_x;
435 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
436 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
438 if (v->field_mode && v->ref_field_type[dir]) {
439 srcY += s->current_picture_ptr->f.linesize[0];
440 srcU += s->current_picture_ptr->f.linesize[1];
441 srcV += s->current_picture_ptr->f.linesize[2];
444 /* for grayscale we should not try to read from unknown area */
445 if (s->flags & CODEC_FLAG_GRAY) {
446 srcU = s->edge_emu_buffer + 18 * s->linesize;
447 srcV = s->edge_emu_buffer + 18 * s->linesize;
450 if (v->rangeredfrm || use_ic
451 || s->h_edge_pos < 22 || v_edge_pos < 22
452 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
453 || (unsigned)(src_y - 1) > v_edge_pos - (my&3) - 16 - 3) {
454 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
456 srcY -= s->mspel * (1 + s->linesize);
457 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,
459 17 + s->mspel * 2, 17 + s->mspel * 2,
460 src_x - s->mspel, src_y - s->mspel,
461 s->h_edge_pos, v_edge_pos);
462 srcY = s->edge_emu_buffer;
463 s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize, srcU, s->uvlinesize,
464 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
465 s->h_edge_pos >> 1, v_edge_pos >> 1);
466 s->vdsp.emulated_edge_mc(uvbuf + 16, s->uvlinesize, srcV, s->uvlinesize,
467 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
468 s->h_edge_pos >> 1, v_edge_pos >> 1);
471 /* if we deal with range reduction we need to scale source blocks */
472 if (v->rangeredfrm) {
477 for (j = 0; j < 17 + s->mspel * 2; j++) {
478 for (i = 0; i < 17 + s->mspel * 2; i++)
479 src[i] = ((src[i] - 128) >> 1) + 128;
484 for (j = 0; j < 9; j++) {
485 for (i = 0; i < 9; i++) {
486 src[i] = ((src[i] - 128) >> 1) + 128;
487 src2[i] = ((src2[i] - 128) >> 1) + 128;
489 src += s->uvlinesize;
490 src2 += s->uvlinesize;
493 /* if we deal with intensity compensation we need to scale source blocks */
499 for (j = 0; j < 17 + s->mspel * 2; j++) {
500 int f = v->field_mode ? v->ref_field_type[dir] : ((j + src_y - s->mspel) & 1) ;
501 for (i = 0; i < 17 + s->mspel * 2; i++)
502 src[i] = luty[f][src[i]];
507 for (j = 0; j < 9; j++) {
508 int f = v->field_mode ? v->ref_field_type[dir] : ((j + uvsrc_y) & 1);
509 for (i = 0; i < 9; i++) {
510 src[i] = lutuv[f][src[i]];
511 src2[i] = lutuv[f][src2[i]];
513 src += s->uvlinesize;
514 src2 += s->uvlinesize;
517 srcY += s->mspel * (1 + s->linesize);
521 dxy = ((my & 3) << 2) | (mx & 3);
522 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
523 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
524 srcY += s->linesize * 8;
525 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
526 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
527 } else { // hpel mc - always used for luma
528 dxy = (my & 2) | ((mx & 2) >> 1);
530 s->hdsp.put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
532 s->hdsp.put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
535 if (s->flags & CODEC_FLAG_GRAY) return;
536 /* Chroma MC always uses qpel bilinear */
537 uvmx = (uvmx & 3) << 1;
538 uvmy = (uvmy & 3) << 1;
540 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
541 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
543 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
544 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
548 static inline int median4(int a, int b, int c, int d)
551 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
552 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
554 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
555 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
559 /** Do motion compensation for 4-MV macroblock - luminance block
561 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
563 MpegEncContext *s = &v->s;
565 int dxy, mx, my, src_x, src_y;
567 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
568 int v_edge_pos = s->v_edge_pos >> v->field_mode;
569 uint8_t (*luty)[256];
572 if ((!v->field_mode ||
573 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
574 !v->s.last_picture.f.data[0])
577 mx = s->mv[dir][n][0];
578 my = s->mv[dir][n][1];
581 if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
582 srcY = s->current_picture.f.data[0];
584 use_ic = v->curr_use_ic;
586 srcY = s->last_picture.f.data[0];
588 use_ic = v->last_use_ic;
591 srcY = s->next_picture.f.data[0];
593 use_ic = v->next_use_ic;
597 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
602 if (v->cur_field_type != v->ref_field_type[dir])
603 my = my - 2 + 4 * v->cur_field_type;
606 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
607 int same_count = 0, opp_count = 0, k;
608 int chosen_mv[2][4][2], f;
610 for (k = 0; k < 4; k++) {
611 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
612 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
613 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
617 f = opp_count > same_count;
618 switch (f ? opp_count : same_count) {
620 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
621 chosen_mv[f][2][0], chosen_mv[f][3][0]);
622 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
623 chosen_mv[f][2][1], chosen_mv[f][3][1]);
626 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
627 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
630 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
631 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
636 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
637 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
638 for (k = 0; k < 4; k++)
639 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
642 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
644 int width = s->avctx->coded_width;
645 int height = s->avctx->coded_height >> 1;
646 if (s->pict_type == AV_PICTURE_TYPE_P) {
647 s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][0] = mx;
648 s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][1] = my;
650 qx = (s->mb_x * 16) + (mx >> 2);
651 qy = (s->mb_y * 8) + (my >> 3);
656 mx -= 4 * (qx - width);
659 else if (qy > height + 1)
660 my -= 8 * (qy - height - 1);
663 if ((v->fcm == ILACE_FRAME) && fieldmv)
664 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
666 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
668 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
670 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
672 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
674 if (v->profile != PROFILE_ADVANCED) {
675 src_x = av_clip(src_x, -16, s->mb_width * 16);
676 src_y = av_clip(src_y, -16, s->mb_height * 16);
678 src_x = av_clip(src_x, -17, s->avctx->coded_width);
679 if (v->fcm == ILACE_FRAME) {
681 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
683 src_y = av_clip(src_y, -18, s->avctx->coded_height);
685 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
689 srcY += src_y * s->linesize + src_x;
690 if (v->field_mode && v->ref_field_type[dir])
691 srcY += s->current_picture_ptr->f.linesize[0];
693 if (fieldmv && !(src_y & 1))
695 if (fieldmv && (src_y & 1) && src_y < 4)
697 if (v->rangeredfrm || use_ic
698 || s->h_edge_pos < 13 || v_edge_pos < 23
699 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
700 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
701 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
702 /* check emulate edge stride and offset */
703 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize, srcY, s->linesize,
704 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
705 src_x - s->mspel, src_y - (s->mspel << fieldmv),
706 s->h_edge_pos, v_edge_pos);
707 srcY = s->edge_emu_buffer;
708 /* if we deal with range reduction we need to scale source blocks */
709 if (v->rangeredfrm) {
714 for (j = 0; j < 9 + s->mspel * 2; j++) {
715 for (i = 0; i < 9 + s->mspel * 2; i++)
716 src[i] = ((src[i] - 128) >> 1) + 128;
717 src += s->linesize << fieldmv;
720 /* if we deal with intensity compensation we need to scale source blocks */
726 for (j = 0; j < 9 + s->mspel * 2; j++) {
727 int f = v->field_mode ? v->ref_field_type[dir] : (((j<<fieldmv)+src_y - (s->mspel << fieldmv)) & 1);
728 for (i = 0; i < 9 + s->mspel * 2; i++)
729 src[i] = luty[f][src[i]];
730 src += s->linesize << fieldmv;
733 srcY += s->mspel * (1 + (s->linesize << fieldmv));
737 dxy = ((my & 3) << 2) | (mx & 3);
739 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
741 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
742 } else { // hpel mc - always used for luma
743 dxy = (my & 2) | ((mx & 2) >> 1);
745 s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
747 s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
751 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
754 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
756 idx = ((a[3] != flag) << 3)
757 | ((a[2] != flag) << 2)
758 | ((a[1] != flag) << 1)
761 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
762 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
764 } else if (count[idx] == 1) {
767 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
768 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
771 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
772 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
775 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
776 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
779 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
780 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
783 } else if (count[idx] == 2) {
785 for (i = 0; i < 3; i++)
790 for (i = t1 + 1; i < 4; i++)
795 *tx = (mvx[t1] + mvx[t2]) / 2;
796 *ty = (mvy[t1] + mvy[t2]) / 2;
804 /** Do motion compensation for 4-MV macroblock - both chroma blocks
806 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
808 MpegEncContext *s = &v->s;
809 H264ChromaContext *h264chroma = &v->h264chroma;
810 uint8_t *srcU, *srcV;
811 int uvmx, uvmy, uvsrc_x, uvsrc_y;
812 int k, tx = 0, ty = 0;
813 int mvx[4], mvy[4], intra[4], mv_f[4];
815 int chroma_ref_type = v->cur_field_type;
816 int v_edge_pos = s->v_edge_pos >> v->field_mode;
817 uint8_t (*lutuv)[256];
820 if (!v->field_mode && !v->s.last_picture.f.data[0])
822 if (s->flags & CODEC_FLAG_GRAY)
825 for (k = 0; k < 4; k++) {
826 mvx[k] = s->mv[dir][k][0];
827 mvy[k] = s->mv[dir][k][1];
828 intra[k] = v->mb_type[0][s->block_index[k]];
830 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
833 /* calculate chroma MV vector from four luma MVs */
834 if (!v->field_mode || (v->field_mode && !v->numref)) {
835 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
836 chroma_ref_type = v->reffield;
838 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
839 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
840 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
841 return; //no need to do MC for intra blocks
845 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
847 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
849 chroma_ref_type = !v->cur_field_type;
851 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
853 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
854 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
855 uvmx = (tx + ((tx & 3) == 3)) >> 1;
856 uvmy = (ty + ((ty & 3) == 3)) >> 1;
858 v->luma_mv[s->mb_x][0] = uvmx;
859 v->luma_mv[s->mb_x][1] = uvmy;
862 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
863 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
865 // Field conversion bias
866 if (v->cur_field_type != chroma_ref_type)
867 uvmy += 2 - 4 * chroma_ref_type;
869 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
870 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
872 if (v->profile != PROFILE_ADVANCED) {
873 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
874 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
876 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
877 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
881 if (v->field_mode && (v->cur_field_type != chroma_ref_type) && v->second_field) {
882 srcU = s->current_picture.f.data[1];
883 srcV = s->current_picture.f.data[2];
884 lutuv = v->curr_lutuv;
885 use_ic = v->curr_use_ic;
887 srcU = s->last_picture.f.data[1];
888 srcV = s->last_picture.f.data[2];
889 lutuv = v->last_lutuv;
890 use_ic = v->last_use_ic;
893 srcU = s->next_picture.f.data[1];
894 srcV = s->next_picture.f.data[2];
895 lutuv = v->next_lutuv;
896 use_ic = v->next_use_ic;
900 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
904 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
905 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
908 if (chroma_ref_type) {
909 srcU += s->current_picture_ptr->f.linesize[1];
910 srcV += s->current_picture_ptr->f.linesize[2];
914 if (v->rangeredfrm || use_ic
915 || s->h_edge_pos < 18 || v_edge_pos < 18
916 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
917 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
918 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize, srcU,
919 s->uvlinesize, 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
920 s->h_edge_pos >> 1, v_edge_pos >> 1);
921 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, s->uvlinesize, srcV,
922 s->uvlinesize, 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
923 s->h_edge_pos >> 1, v_edge_pos >> 1);
924 srcU = s->edge_emu_buffer;
925 srcV = s->edge_emu_buffer + 16;
927 /* if we deal with range reduction we need to scale source blocks */
928 if (v->rangeredfrm) {
934 for (j = 0; j < 9; j++) {
935 for (i = 0; i < 9; i++) {
936 src[i] = ((src[i] - 128) >> 1) + 128;
937 src2[i] = ((src2[i] - 128) >> 1) + 128;
939 src += s->uvlinesize;
940 src2 += s->uvlinesize;
943 /* if we deal with intensity compensation we need to scale source blocks */
950 for (j = 0; j < 9; j++) {
951 int f = v->field_mode ? chroma_ref_type : ((j + uvsrc_y) & 1);
952 for (i = 0; i < 9; i++) {
953 src[i] = lutuv[f][src[i]];
954 src2[i] = lutuv[f][src2[i]];
956 src += s->uvlinesize;
957 src2 += s->uvlinesize;
962 /* Chroma MC always uses qpel bilinear */
963 uvmx = (uvmx & 3) << 1;
964 uvmy = (uvmy & 3) << 1;
966 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
967 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
969 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
970 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
974 /** Do motion compensation for 4-MV interlaced frame chroma macroblock (both U and V)
976 static void vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)
978 MpegEncContext *s = &v->s;
979 H264ChromaContext *h264chroma = &v->h264chroma;
980 uint8_t *srcU, *srcV;
981 int uvsrc_x, uvsrc_y;
982 int uvmx_field[4], uvmy_field[4];
984 int fieldmv = v->blk_mv_type[s->block_index[0]];
985 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
986 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
987 int v_edge_pos = s->v_edge_pos >> 1;
989 uint8_t (*lutuv)[256];
991 if (s->flags & CODEC_FLAG_GRAY)
994 for (i = 0; i < 4; i++) {
995 int d = i < 2 ? dir: dir2;
997 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
1000 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
1002 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
1005 for (i = 0; i < 4; i++) {
1006 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
1007 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
1008 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
1009 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
1010 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1011 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1012 if (i < 2 ? dir : dir2) {
1013 srcU = s->next_picture.f.data[1];
1014 srcV = s->next_picture.f.data[2];
1015 lutuv = v->next_lutuv;
1016 use_ic = v->next_use_ic;
1018 srcU = s->last_picture.f.data[1];
1019 srcV = s->last_picture.f.data[2];
1020 lutuv = v->last_lutuv;
1021 use_ic = v->last_use_ic;
1025 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1026 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1027 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
1028 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
1030 if (fieldmv && !(uvsrc_y & 1))
1031 v_edge_pos = (s->v_edge_pos >> 1) - 1;
1033 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
1036 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
1037 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
1038 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
1039 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize, srcU,
1040 s->uvlinesize, 5, (5 << fieldmv), uvsrc_x,
1041 uvsrc_y, s->h_edge_pos >> 1, v_edge_pos);
1042 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, s->uvlinesize, srcV,
1043 s->uvlinesize, 5, (5 << fieldmv), uvsrc_x,
1044 uvsrc_y, s->h_edge_pos >> 1, v_edge_pos);
1045 srcU = s->edge_emu_buffer;
1046 srcV = s->edge_emu_buffer + 16;
1048 /* if we deal with intensity compensation we need to scale source blocks */
1051 uint8_t *src, *src2;
1055 for (j = 0; j < 5; j++) {
1056 int f = (uvsrc_y + (j << fieldmv)) & 1;
1057 for (i = 0; i < 5; i++) {
1058 src[i] = lutuv[f][src[i]];
1059 src2[i] = lutuv[f][src2[i]];
1061 src += s->uvlinesize << fieldmv;
1062 src2 += s->uvlinesize << fieldmv;
1068 h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1069 h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1071 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1072 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1076 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1077 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1079 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]);
1080 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]);
1086 /***********************************************************************/
1088 * @name VC-1 Block-level functions
1089 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1095 * @brief Get macroblock-level quantizer scale
1097 #define GET_MQUANT() \
1098 if (v->dquantfrm) { \
1100 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1101 if (v->dqbilevel) { \
1102 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1104 mqdiff = get_bits(gb, 3); \
1106 mquant = v->pq + mqdiff; \
1108 mquant = get_bits(gb, 5); \
1111 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1112 edges = 1 << v->dqsbedge; \
1113 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1114 edges = (3 << v->dqsbedge) % 15; \
1115 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1117 if ((edges&1) && !s->mb_x) \
1118 mquant = v->altpq; \
1119 if ((edges&2) && s->first_slice_line) \
1120 mquant = v->altpq; \
1121 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1122 mquant = v->altpq; \
1123 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1124 mquant = v->altpq; \
1125 if (!mquant || mquant > 31) { \
1126 av_log(v->s.avctx, AV_LOG_ERROR, \
1127 "Overriding invalid mquant %d\n", mquant); \
1133 * @def GET_MVDATA(_dmv_x, _dmv_y)
1134 * @brief Get MV differentials
1135 * @see MVDATA decoding from 8.3.5.2, p(1)20
1136 * @param _dmv_x Horizontal differential for decoded MV
1137 * @param _dmv_y Vertical differential for decoded MV
1139 #define GET_MVDATA(_dmv_x, _dmv_y) \
1140 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1141 VC1_MV_DIFF_VLC_BITS, 2); \
1143 mb_has_coeffs = 1; \
1146 mb_has_coeffs = 0; \
1149 _dmv_x = _dmv_y = 0; \
1150 } else if (index == 35) { \
1151 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1152 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1153 } else if (index == 36) { \
1158 index1 = index % 6; \
1159 if (!s->quarter_sample && index1 == 5) val = 1; \
1161 if (size_table[index1] - val > 0) \
1162 val = get_bits(gb, size_table[index1] - val); \
1164 sign = 0 - (val&1); \
1165 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1167 index1 = index / 6; \
1168 if (!s->quarter_sample && index1 == 5) val = 1; \
1170 if (size_table[index1] - val > 0) \
1171 val = get_bits(gb, size_table[index1] - val); \
1173 sign = 0 - (val & 1); \
1174 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1177 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1178 int *dmv_y, int *pred_flag)
1181 int extend_x = 0, extend_y = 0;
1182 GetBitContext *gb = &v->s.gb;
1185 const int* offs_tab;
1188 bits = VC1_2REF_MVDATA_VLC_BITS;
1191 bits = VC1_1REF_MVDATA_VLC_BITS;
1194 switch (v->dmvrange) {
1202 extend_x = extend_y = 1;
1205 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1207 *dmv_x = get_bits(gb, v->k_x);
1208 *dmv_y = get_bits(gb, v->k_y);
1211 *pred_flag = *dmv_y & 1;
1212 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1214 *dmv_y = (*dmv_y + (*dmv_y & 1)) >> 1;
1219 av_assert0(index < esc);
1221 offs_tab = offset_table2;
1223 offs_tab = offset_table1;
1224 index1 = (index + 1) % 9;
1226 val = get_bits(gb, index1 + extend_x);
1227 sign = 0 -(val & 1);
1228 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1232 offs_tab = offset_table2;
1234 offs_tab = offset_table1;
1235 index1 = (index + 1) / 9;
1236 if (index1 > v->numref) {
1237 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1238 sign = 0 - (val & 1);
1239 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1242 if (v->numref && pred_flag)
1243 *pred_flag = index1 & 1;
1247 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1249 int scaledvalue, refdist;
1250 int scalesame1, scalesame2;
1251 int scalezone1_x, zone1offset_x;
1252 int table_index = dir ^ v->second_field;
1254 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1255 refdist = v->refdist;
1257 refdist = dir ? v->brfd : v->frfd;
1260 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1261 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1262 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1263 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1268 if (FFABS(n) < scalezone1_x)
1269 scaledvalue = (n * scalesame1) >> 8;
1272 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1274 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1277 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1280 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1282 int scaledvalue, refdist;
1283 int scalesame1, scalesame2;
1284 int scalezone1_y, zone1offset_y;
1285 int table_index = dir ^ v->second_field;
1287 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1288 refdist = v->refdist;
1290 refdist = dir ? v->brfd : v->frfd;
1293 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1294 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1295 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1296 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1301 if (FFABS(n) < scalezone1_y)
1302 scaledvalue = (n * scalesame1) >> 8;
1305 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1307 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1311 if (v->cur_field_type && !v->ref_field_type[dir])
1312 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1314 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1317 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1319 int scalezone1_x, zone1offset_x;
1320 int scaleopp1, scaleopp2, brfd;
1323 brfd = FFMIN(v->brfd, 3);
1324 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1325 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1326 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1327 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1332 if (FFABS(n) < scalezone1_x)
1333 scaledvalue = (n * scaleopp1) >> 8;
1336 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1338 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1341 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1344 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1346 int scalezone1_y, zone1offset_y;
1347 int scaleopp1, scaleopp2, brfd;
1350 brfd = FFMIN(v->brfd, 3);
1351 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1352 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1353 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1354 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1359 if (FFABS(n) < scalezone1_y)
1360 scaledvalue = (n * scaleopp1) >> 8;
1363 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1365 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1368 if (v->cur_field_type && !v->ref_field_type[dir]) {
1369 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1371 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1375 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1378 int brfd, scalesame;
1379 int hpel = 1 - v->s.quarter_sample;
1382 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1384 n = scaleforsame_y(v, i, n, dir) << hpel;
1386 n = scaleforsame_x(v, n, dir) << hpel;
1389 brfd = FFMIN(v->brfd, 3);
1390 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1392 n = (n * scalesame >> 8) << hpel;
1396 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1399 int refdist, scaleopp;
1400 int hpel = 1 - v->s.quarter_sample;
1403 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1405 n = scaleforopp_y(v, n, dir) << hpel;
1407 n = scaleforopp_x(v, n) << hpel;
1410 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1411 refdist = FFMIN(v->refdist, 3);
1413 refdist = dir ? v->brfd : v->frfd;
1414 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1416 n = (n * scaleopp >> 8) << hpel;
1420 /** Predict and set motion vector
1422 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1423 int mv1, int r_x, int r_y, uint8_t* is_intra,
1424 int pred_flag, int dir)
1426 MpegEncContext *s = &v->s;
1427 int xy, wrap, off = 0;
1431 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1432 int opposite, a_f, b_f, c_f;
1433 int16_t field_predA[2];
1434 int16_t field_predB[2];
1435 int16_t field_predC[2];
1436 int a_valid, b_valid, c_valid;
1437 int hybridmv_thresh, y_bias = 0;
1439 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1440 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1444 /* scale MV difference to be quad-pel */
1445 dmv_x <<= 1 - s->quarter_sample;
1446 dmv_y <<= 1 - s->quarter_sample;
1448 wrap = s->b8_stride;
1449 xy = s->block_index[n];
1452 s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
1453 s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
1454 s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
1455 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
1456 if (mv1) { /* duplicate motion data for 1-MV block */
1457 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1458 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1459 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1460 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1461 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1462 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1463 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1464 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1465 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1466 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1467 s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1468 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1469 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1474 C = s->current_picture.motion_val[dir][xy - 1 + v->blocks_off];
1475 A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
1477 if (v->field_mode && mixedmv_pic)
1478 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1480 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1482 //in 4-MV mode different blocks have different B predictor position
1485 off = (s->mb_x > 0) ? -1 : 1;
1488 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1497 B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
1499 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1500 b_valid = a_valid && (s->mb_width > 1);
1501 c_valid = s->mb_x || (n == 1 || n == 3);
1502 if (v->field_mode) {
1503 a_valid = a_valid && !is_intra[xy - wrap];
1504 b_valid = b_valid && !is_intra[xy - wrap + off];
1505 c_valid = c_valid && !is_intra[xy - 1];
1509 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1510 num_oppfield += a_f;
1511 num_samefield += 1 - a_f;
1512 field_predA[0] = A[0];
1513 field_predA[1] = A[1];
1515 field_predA[0] = field_predA[1] = 0;
1519 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1520 num_oppfield += b_f;
1521 num_samefield += 1 - b_f;
1522 field_predB[0] = B[0];
1523 field_predB[1] = B[1];
1525 field_predB[0] = field_predB[1] = 0;
1529 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1530 num_oppfield += c_f;
1531 num_samefield += 1 - c_f;
1532 field_predC[0] = C[0];
1533 field_predC[1] = C[1];
1535 field_predC[0] = field_predC[1] = 0;
1539 if (v->field_mode) {
1541 // REFFIELD determines if the last field or the second-last field is
1542 // to be used as reference
1543 opposite = 1 - v->reffield;
1545 if (num_samefield <= num_oppfield)
1546 opposite = 1 - pred_flag;
1548 opposite = pred_flag;
1553 if (a_valid && !a_f) {
1554 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1555 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1557 if (b_valid && !b_f) {
1558 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1559 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1561 if (c_valid && !c_f) {
1562 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1563 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1565 v->mv_f[dir][xy + v->blocks_off] = 1;
1566 v->ref_field_type[dir] = !v->cur_field_type;
1568 if (a_valid && a_f) {
1569 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1570 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1572 if (b_valid && b_f) {
1573 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1574 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1576 if (c_valid && c_f) {
1577 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1578 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1580 v->mv_f[dir][xy + v->blocks_off] = 0;
1581 v->ref_field_type[dir] = v->cur_field_type;
1585 px = field_predA[0];
1586 py = field_predA[1];
1587 } else if (c_valid) {
1588 px = field_predC[0];
1589 py = field_predC[1];
1590 } else if (b_valid) {
1591 px = field_predB[0];
1592 py = field_predB[1];
1598 if (num_samefield + num_oppfield > 1) {
1599 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1600 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1603 /* Pullback MV as specified in 8.3.5.3.4 */
1604 if (!v->field_mode) {
1606 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1607 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1608 X = (s->mb_width << 6) - 4;
1609 Y = (s->mb_height << 6) - 4;
1611 if (qx + px < -60) px = -60 - qx;
1612 if (qy + py < -60) py = -60 - qy;
1614 if (qx + px < -28) px = -28 - qx;
1615 if (qy + py < -28) py = -28 - qy;
1617 if (qx + px > X) px = X - qx;
1618 if (qy + py > Y) py = Y - qy;
1621 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1622 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1623 hybridmv_thresh = 32;
1624 if (a_valid && c_valid) {
1625 if (is_intra[xy - wrap])
1626 sum = FFABS(px) + FFABS(py);
1628 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1629 if (sum > hybridmv_thresh) {
1630 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1631 px = field_predA[0];
1632 py = field_predA[1];
1634 px = field_predC[0];
1635 py = field_predC[1];
1638 if (is_intra[xy - 1])
1639 sum = FFABS(px) + FFABS(py);
1641 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1642 if (sum > hybridmv_thresh) {
1643 if (get_bits1(&s->gb)) {
1644 px = field_predA[0];
1645 py = field_predA[1];
1647 px = field_predC[0];
1648 py = field_predC[1];
1655 if (v->field_mode && v->numref)
1657 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1659 /* store MV using signed modulus of MV range defined in 4.11 */
1660 s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1661 s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
1662 if (mv1) { /* duplicate motion data for 1-MV block */
1663 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1664 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1665 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1666 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1667 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1668 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1669 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1670 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];
1674 /** Predict and set motion vector for interlaced frame picture MBs
1676 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1677 int mvn, int r_x, int r_y, uint8_t* is_intra, int dir)
1679 MpegEncContext *s = &v->s;
1680 int xy, wrap, off = 0;
1681 int A[2], B[2], C[2];
1683 int a_valid = 0, b_valid = 0, c_valid = 0;
1684 int field_a, field_b, field_c; // 0: same, 1: opposit
1685 int total_valid, num_samefield, num_oppfield;
1686 int pos_c, pos_b, n_adj;
1688 wrap = s->b8_stride;
1689 xy = s->block_index[n];
1692 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1693 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1694 s->current_picture.motion_val[1][xy][0] = 0;
1695 s->current_picture.motion_val[1][xy][1] = 0;
1696 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1697 s->current_picture.motion_val[0][xy + 1][0] = 0;
1698 s->current_picture.motion_val[0][xy + 1][1] = 0;
1699 s->current_picture.motion_val[0][xy + wrap][0] = 0;
1700 s->current_picture.motion_val[0][xy + wrap][1] = 0;
1701 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1702 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1703 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1704 s->current_picture.motion_val[1][xy + 1][0] = 0;
1705 s->current_picture.motion_val[1][xy + 1][1] = 0;
1706 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1707 s->current_picture.motion_val[1][xy + wrap][1] = 0;
1708 s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
1709 s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
1714 off = ((n == 0) || (n == 1)) ? 1 : -1;
1716 if (s->mb_x || (n == 1) || (n == 3)) {
1717 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1718 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1719 A[0] = s->current_picture.motion_val[dir][xy - 1][0];
1720 A[1] = s->current_picture.motion_val[dir][xy - 1][1];
1722 } else { // current block has frame mv and cand. has field MV (so average)
1723 A[0] = (s->current_picture.motion_val[dir][xy - 1][0]
1724 + s->current_picture.motion_val[dir][xy - 1 + off * wrap][0] + 1) >> 1;
1725 A[1] = (s->current_picture.motion_val[dir][xy - 1][1]
1726 + s->current_picture.motion_val[dir][xy - 1 + off * wrap][1] + 1) >> 1;
1729 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1735 /* Predict B and C */
1736 B[0] = B[1] = C[0] = C[1] = 0;
1737 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1738 if (!s->first_slice_line) {
1739 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1742 pos_b = s->block_index[n_adj] - 2 * wrap;
1743 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1744 n_adj = (n & 2) | (n & 1);
1746 B[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][0];
1747 B[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][1];
1748 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1749 B[0] = (B[0] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1750 B[1] = (B[1] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1753 if (s->mb_width > 1) {
1754 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1757 pos_c = s->block_index[2] - 2 * wrap + 2;
1758 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1761 C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][0];
1762 C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][1];
1763 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1764 C[0] = (1 + C[0] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1765 C[1] = (1 + C[1] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1767 if (s->mb_x == s->mb_width - 1) {
1768 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1771 pos_c = s->block_index[3] - 2 * wrap - 2;
1772 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1775 C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][0];
1776 C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][1];
1777 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1778 C[0] = (1 + C[0] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1779 C[1] = (1 + C[1] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1788 pos_b = s->block_index[1];
1790 B[0] = s->current_picture.motion_val[dir][pos_b][0];
1791 B[1] = s->current_picture.motion_val[dir][pos_b][1];
1792 pos_c = s->block_index[0];
1794 C[0] = s->current_picture.motion_val[dir][pos_c][0];
1795 C[1] = s->current_picture.motion_val[dir][pos_c][1];
1798 total_valid = a_valid + b_valid + c_valid;
1799 // check if predictor A is out of bounds
1800 if (!s->mb_x && !(n == 1 || n == 3)) {
1803 // check if predictor B is out of bounds
1804 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1805 B[0] = B[1] = C[0] = C[1] = 0;
1807 if (!v->blk_mv_type[xy]) {
1808 if (s->mb_width == 1) {
1812 if (total_valid >= 2) {
1813 px = mid_pred(A[0], B[0], C[0]);
1814 py = mid_pred(A[1], B[1], C[1]);
1815 } else if (total_valid) {
1816 if (a_valid) { px = A[0]; py = A[1]; }
1817 else if (b_valid) { px = B[0]; py = B[1]; }
1818 else if (c_valid) { px = C[0]; py = C[1]; }
1824 field_a = (A[1] & 4) ? 1 : 0;
1828 field_b = (B[1] & 4) ? 1 : 0;
1832 field_c = (C[1] & 4) ? 1 : 0;
1836 num_oppfield = field_a + field_b + field_c;
1837 num_samefield = total_valid - num_oppfield;
1838 if (total_valid == 3) {
1839 if ((num_samefield == 3) || (num_oppfield == 3)) {
1840 px = mid_pred(A[0], B[0], C[0]);
1841 py = mid_pred(A[1], B[1], C[1]);
1842 } else if (num_samefield >= num_oppfield) {
1843 /* take one MV from same field set depending on priority
1844 the check for B may not be necessary */
1845 px = !field_a ? A[0] : B[0];
1846 py = !field_a ? A[1] : B[1];
1848 px = field_a ? A[0] : B[0];
1849 py = field_a ? A[1] : B[1];
1851 } else if (total_valid == 2) {
1852 if (num_samefield >= num_oppfield) {
1853 if (!field_a && a_valid) {
1856 } else if (!field_b && b_valid) {
1859 } else /*if (c_valid)*/ {
1860 av_assert1(c_valid);
1863 } /*else px = py = 0;*/
1865 if (field_a && a_valid) {
1868 } else /*if (field_b && b_valid)*/ {
1869 av_assert1(field_b && b_valid);
1872 } /*else if (c_valid) {
1877 } else if (total_valid == 1) {
1878 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1879 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1883 /* store MV using signed modulus of MV range defined in 4.11 */
1884 s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1885 s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1886 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1887 s->current_picture.motion_val[dir][xy + 1 ][0] = s->current_picture.motion_val[dir][xy][0];
1888 s->current_picture.motion_val[dir][xy + 1 ][1] = s->current_picture.motion_val[dir][xy][1];
1889 s->current_picture.motion_val[dir][xy + wrap ][0] = s->current_picture.motion_val[dir][xy][0];
1890 s->current_picture.motion_val[dir][xy + wrap ][1] = s->current_picture.motion_val[dir][xy][1];
1891 s->current_picture.motion_val[dir][xy + wrap + 1][0] = s->current_picture.motion_val[dir][xy][0];
1892 s->current_picture.motion_val[dir][xy + wrap + 1][1] = s->current_picture.motion_val[dir][xy][1];
1893 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1894 s->current_picture.motion_val[dir][xy + 1][0] = s->current_picture.motion_val[dir][xy][0];
1895 s->current_picture.motion_val[dir][xy + 1][1] = s->current_picture.motion_val[dir][xy][1];
1896 s->mv[dir][n + 1][0] = s->mv[dir][n][0];
1897 s->mv[dir][n + 1][1] = s->mv[dir][n][1];
1901 /** Motion compensation for direct or interpolated blocks in B-frames
1903 static void vc1_interp_mc(VC1Context *v)
1905 MpegEncContext *s = &v->s;
1906 H264ChromaContext *h264chroma = &v->h264chroma;
1907 uint8_t *srcY, *srcU, *srcV;
1908 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1910 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1911 int use_ic = v->next_use_ic;
1913 if (!v->field_mode && !v->s.next_picture.f.data[0])
1916 mx = s->mv[1][0][0];
1917 my = s->mv[1][0][1];
1918 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1919 uvmy = (my + ((my & 3) == 3)) >> 1;
1920 if (v->field_mode) {
1921 if (v->cur_field_type != v->ref_field_type[1])
1922 my = my - 2 + 4 * v->cur_field_type;
1923 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1926 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1927 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1929 srcY = s->next_picture.f.data[0];
1930 srcU = s->next_picture.f.data[1];
1931 srcV = s->next_picture.f.data[2];
1933 src_x = s->mb_x * 16 + (mx >> 2);
1934 src_y = s->mb_y * 16 + (my >> 2);
1935 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1936 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1938 if (v->profile != PROFILE_ADVANCED) {
1939 src_x = av_clip( src_x, -16, s->mb_width * 16);
1940 src_y = av_clip( src_y, -16, s->mb_height * 16);
1941 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1942 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1944 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1945 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1946 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1947 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1950 srcY += src_y * s->linesize + src_x;
1951 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1952 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1954 if (v->field_mode && v->ref_field_type[1]) {
1955 srcY += s->current_picture_ptr->f.linesize[0];
1956 srcU += s->current_picture_ptr->f.linesize[1];
1957 srcV += s->current_picture_ptr->f.linesize[2];
1960 /* for grayscale we should not try to read from unknown area */
1961 if (s->flags & CODEC_FLAG_GRAY) {
1962 srcU = s->edge_emu_buffer + 18 * s->linesize;
1963 srcV = s->edge_emu_buffer + 18 * s->linesize;
1966 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22 || use_ic
1967 || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1968 || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1969 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1971 srcY -= s->mspel * (1 + s->linesize);
1972 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize, srcY, s->linesize,
1973 17 + s->mspel * 2, 17 + s->mspel * 2,
1974 src_x - s->mspel, src_y - s->mspel,
1975 s->h_edge_pos, v_edge_pos);
1976 srcY = s->edge_emu_buffer;
1977 s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize, srcU, s->uvlinesize,
1978 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
1979 s->h_edge_pos >> 1, v_edge_pos >> 1);
1980 s->vdsp.emulated_edge_mc(uvbuf + 16, s->uvlinesize, srcV, s->uvlinesize,
1981 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
1982 s->h_edge_pos >> 1, v_edge_pos >> 1);
1985 /* if we deal with range reduction we need to scale source blocks */
1986 if (v->rangeredfrm) {
1988 uint8_t *src, *src2;
1991 for (j = 0; j < 17 + s->mspel * 2; j++) {
1992 for (i = 0; i < 17 + s->mspel * 2; i++)
1993 src[i] = ((src[i] - 128) >> 1) + 128;
1998 for (j = 0; j < 9; j++) {
1999 for (i = 0; i < 9; i++) {
2000 src[i] = ((src[i] - 128) >> 1) + 128;
2001 src2[i] = ((src2[i] - 128) >> 1) + 128;
2003 src += s->uvlinesize;
2004 src2 += s->uvlinesize;
2009 uint8_t (*luty )[256] = v->next_luty;
2010 uint8_t (*lutuv)[256] = v->next_lutuv;
2012 uint8_t *src, *src2;
2015 for (j = 0; j < 17 + s->mspel * 2; j++) {
2016 int f = v->field_mode ? v->ref_field_type[1] : ((j+src_y - s->mspel) & 1);
2017 for (i = 0; i < 17 + s->mspel * 2; i++)
2018 src[i] = luty[f][src[i]];
2023 for (j = 0; j < 9; j++) {
2024 int f = v->field_mode ? v->ref_field_type[1] : ((j+uvsrc_y) & 1);
2025 for (i = 0; i < 9; i++) {
2026 src[i] = lutuv[f][src[i]];
2027 src2[i] = lutuv[f][src2[i]];
2029 src += s->uvlinesize;
2030 src2 += s->uvlinesize;
2033 srcY += s->mspel * (1 + s->linesize);
2040 dxy = ((my & 3) << 2) | (mx & 3);
2041 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
2042 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
2043 srcY += s->linesize * 8;
2044 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
2045 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
2047 dxy = (my & 2) | ((mx & 2) >> 1);
2050 s->hdsp.avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
2052 s->hdsp.avg_no_rnd_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, 16);
2055 if (s->flags & CODEC_FLAG_GRAY) return;
2056 /* Chroma MC always uses qpel blilinear */
2057 uvmx = (uvmx & 3) << 1;
2058 uvmy = (uvmy & 3) << 1;
2060 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2061 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2063 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2064 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2068 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2072 #if B_FRACTION_DEN==256
2076 return 2 * ((value * n + 255) >> 9);
2077 return (value * n + 128) >> 8;
2080 n -= B_FRACTION_DEN;
2082 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2083 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2087 /** Reconstruct motion vector for B-frame and do motion compensation
2089 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2090 int direct, int mode)
2097 if (mode == BMV_TYPE_INTERPOLATED) {
2103 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2106 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2107 int direct, int mvtype)
2109 MpegEncContext *s = &v->s;
2110 int xy, wrap, off = 0;
2115 const uint8_t *is_intra = v->mb_type[0];
2119 /* scale MV difference to be quad-pel */
2120 dmv_x[0] <<= 1 - s->quarter_sample;
2121 dmv_y[0] <<= 1 - s->quarter_sample;
2122 dmv_x[1] <<= 1 - s->quarter_sample;
2123 dmv_y[1] <<= 1 - s->quarter_sample;
2125 wrap = s->b8_stride;
2126 xy = s->block_index[0];
2129 s->current_picture.motion_val[0][xy + v->blocks_off][0] =
2130 s->current_picture.motion_val[0][xy + v->blocks_off][1] =
2131 s->current_picture.motion_val[1][xy + v->blocks_off][0] =
2132 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
2135 if (!v->field_mode) {
2136 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2137 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2138 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2139 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2141 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2142 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));
2143 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));
2144 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));
2145 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));
2148 s->current_picture.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2149 s->current_picture.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2150 s->current_picture.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2151 s->current_picture.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2155 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2156 C = s->current_picture.motion_val[0][xy - 2];
2157 A = s->current_picture.motion_val[0][xy - wrap * 2];
2158 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2159 B = s->current_picture.motion_val[0][xy - wrap * 2 + off];
2161 if (!s->mb_x) C[0] = C[1] = 0;
2162 if (!s->first_slice_line) { // predictor A is not out of bounds
2163 if (s->mb_width == 1) {
2167 px = mid_pred(A[0], B[0], C[0]);
2168 py = mid_pred(A[1], B[1], C[1]);
2170 } else if (s->mb_x) { // predictor C is not out of bounds
2176 /* Pullback MV as specified in 8.3.5.3.4 */
2179 if (v->profile < PROFILE_ADVANCED) {
2180 qx = (s->mb_x << 5);
2181 qy = (s->mb_y << 5);
2182 X = (s->mb_width << 5) - 4;
2183 Y = (s->mb_height << 5) - 4;
2184 if (qx + px < -28) px = -28 - qx;
2185 if (qy + py < -28) py = -28 - qy;
2186 if (qx + px > X) px = X - qx;
2187 if (qy + py > Y) py = Y - qy;
2189 qx = (s->mb_x << 6);
2190 qy = (s->mb_y << 6);
2191 X = (s->mb_width << 6) - 4;
2192 Y = (s->mb_height << 6) - 4;
2193 if (qx + px < -60) px = -60 - qx;
2194 if (qy + py < -60) py = -60 - qy;
2195 if (qx + px > X) px = X - qx;
2196 if (qy + py > Y) py = Y - qy;
2199 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2200 if (0 && !s->first_slice_line && s->mb_x) {
2201 if (is_intra[xy - wrap])
2202 sum = FFABS(px) + FFABS(py);
2204 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2206 if (get_bits1(&s->gb)) {
2214 if (is_intra[xy - 2])
2215 sum = FFABS(px) + FFABS(py);
2217 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2219 if (get_bits1(&s->gb)) {
2229 /* store MV using signed modulus of MV range defined in 4.11 */
2230 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2231 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2233 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2234 C = s->current_picture.motion_val[1][xy - 2];
2235 A = s->current_picture.motion_val[1][xy - wrap * 2];
2236 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2237 B = s->current_picture.motion_val[1][xy - wrap * 2 + off];
2241 if (!s->first_slice_line) { // predictor A is not out of bounds
2242 if (s->mb_width == 1) {
2246 px = mid_pred(A[0], B[0], C[0]);
2247 py = mid_pred(A[1], B[1], C[1]);
2249 } else if (s->mb_x) { // predictor C is not out of bounds
2255 /* Pullback MV as specified in 8.3.5.3.4 */
2258 if (v->profile < PROFILE_ADVANCED) {
2259 qx = (s->mb_x << 5);
2260 qy = (s->mb_y << 5);
2261 X = (s->mb_width << 5) - 4;
2262 Y = (s->mb_height << 5) - 4;
2263 if (qx + px < -28) px = -28 - qx;
2264 if (qy + py < -28) py = -28 - qy;
2265 if (qx + px > X) px = X - qx;
2266 if (qy + py > Y) py = Y - qy;
2268 qx = (s->mb_x << 6);
2269 qy = (s->mb_y << 6);
2270 X = (s->mb_width << 6) - 4;
2271 Y = (s->mb_height << 6) - 4;
2272 if (qx + px < -60) px = -60 - qx;
2273 if (qy + py < -60) py = -60 - qy;
2274 if (qx + px > X) px = X - qx;
2275 if (qy + py > Y) py = Y - qy;
2278 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2279 if (0 && !s->first_slice_line && s->mb_x) {
2280 if (is_intra[xy - wrap])
2281 sum = FFABS(px) + FFABS(py);
2283 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2285 if (get_bits1(&s->gb)) {
2293 if (is_intra[xy - 2])
2294 sum = FFABS(px) + FFABS(py);
2296 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2298 if (get_bits1(&s->gb)) {
2308 /* store MV using signed modulus of MV range defined in 4.11 */
2310 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2311 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2313 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2314 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2315 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2316 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2319 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2321 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2322 MpegEncContext *s = &v->s;
2323 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2325 if (v->bmvtype == BMV_TYPE_DIRECT) {
2326 int total_opp, k, f;
2327 if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2328 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2329 v->bfraction, 0, s->quarter_sample);
2330 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2331 v->bfraction, 0, s->quarter_sample);
2332 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2333 v->bfraction, 1, s->quarter_sample);
2334 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2335 v->bfraction, 1, s->quarter_sample);
2337 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2338 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2339 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2340 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2341 f = (total_opp > 2) ? 1 : 0;
2343 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2344 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2347 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2348 for (k = 0; k < 4; k++) {
2349 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2350 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2351 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2352 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2353 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2354 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2358 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2359 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);
2360 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);
2363 if (dir) { // backward
2364 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);
2365 if (n == 3 || mv1) {
2366 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2369 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);
2370 if (n == 3 || mv1) {
2371 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2376 /** Get predicted DC value for I-frames only
2377 * prediction dir: left=0, top=1
2378 * @param s MpegEncContext
2379 * @param overlap flag indicating that overlap filtering is used
2380 * @param pq integer part of picture quantizer
2381 * @param[in] n block index in the current MB
2382 * @param dc_val_ptr Pointer to DC predictor
2383 * @param dir_ptr Prediction direction for use in AC prediction
2385 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2386 int16_t **dc_val_ptr, int *dir_ptr)
2388 int a, b, c, wrap, pred, scale;
2390 static const uint16_t dcpred[32] = {
2391 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2392 114, 102, 93, 85, 79, 73, 68, 64,
2393 60, 57, 54, 51, 49, 47, 45, 43,
2394 41, 39, 38, 37, 35, 34, 33
2397 /* find prediction - wmv3_dc_scale always used here in fact */
2398 if (n < 4) scale = s->y_dc_scale;
2399 else scale = s->c_dc_scale;
2401 wrap = s->block_wrap[n];
2402 dc_val = s->dc_val[0] + s->block_index[n];
2408 b = dc_val[ - 1 - wrap];
2409 a = dc_val[ - wrap];
2411 if (pq < 9 || !overlap) {
2412 /* Set outer values */
2413 if (s->first_slice_line && (n != 2 && n != 3))
2414 b = a = dcpred[scale];
2415 if (s->mb_x == 0 && (n != 1 && n != 3))
2416 b = c = dcpred[scale];
2418 /* Set outer values */
2419 if (s->first_slice_line && (n != 2 && n != 3))
2421 if (s->mb_x == 0 && (n != 1 && n != 3))
2425 if (abs(a - b) <= abs(b - c)) {
2427 *dir_ptr = 1; // left
2430 *dir_ptr = 0; // top
2433 /* update predictor */
2434 *dc_val_ptr = &dc_val[0];
2439 /** Get predicted DC value
2440 * prediction dir: left=0, top=1
2441 * @param s MpegEncContext
2442 * @param overlap flag indicating that overlap filtering is used
2443 * @param pq integer part of picture quantizer
2444 * @param[in] n block index in the current MB
2445 * @param a_avail flag indicating top block availability
2446 * @param c_avail flag indicating left block availability
2447 * @param dc_val_ptr Pointer to DC predictor
2448 * @param dir_ptr Prediction direction for use in AC prediction
2450 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2451 int a_avail, int c_avail,
2452 int16_t **dc_val_ptr, int *dir_ptr)
2454 int a, b, c, wrap, pred;
2456 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2460 wrap = s->block_wrap[n];
2461 dc_val = s->dc_val[0] + s->block_index[n];
2467 b = dc_val[ - 1 - wrap];
2468 a = dc_val[ - wrap];
2469 /* scale predictors if needed */
2470 q1 = s->current_picture.qscale_table[mb_pos];
2471 dqscale_index = s->y_dc_scale_table[q1] - 1;
2472 if (dqscale_index < 0)
2474 if (c_avail && (n != 1 && n != 3)) {
2475 q2 = s->current_picture.qscale_table[mb_pos - 1];
2477 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2479 if (a_avail && (n != 2 && n != 3)) {
2480 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2482 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2484 if (a_avail && c_avail && (n != 3)) {
2489 off -= s->mb_stride;
2490 q2 = s->current_picture.qscale_table[off];
2492 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2495 if (a_avail && c_avail) {
2496 if (abs(a - b) <= abs(b - c)) {
2498 *dir_ptr = 1; // left
2501 *dir_ptr = 0; // top
2503 } else if (a_avail) {
2505 *dir_ptr = 0; // top
2506 } else if (c_avail) {
2508 *dir_ptr = 1; // left
2511 *dir_ptr = 1; // left
2514 /* update predictor */
2515 *dc_val_ptr = &dc_val[0];
2519 /** @} */ // Block group
2522 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2523 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2527 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2528 uint8_t **coded_block_ptr)
2530 int xy, wrap, pred, a, b, c;
2532 xy = s->block_index[n];
2533 wrap = s->b8_stride;
2538 a = s->coded_block[xy - 1 ];
2539 b = s->coded_block[xy - 1 - wrap];
2540 c = s->coded_block[xy - wrap];
2549 *coded_block_ptr = &s->coded_block[xy];
2555 * Decode one AC coefficient
2556 * @param v The VC1 context
2557 * @param last Last coefficient
2558 * @param skip How much zero coefficients to skip
2559 * @param value Decoded AC coefficient value
2560 * @param codingset set of VLC to decode data
2563 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2564 int *value, int codingset)
2566 GetBitContext *gb = &v->s.gb;
2567 int index, escape, run = 0, level = 0, lst = 0;
2569 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2570 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2571 run = vc1_index_decode_table[codingset][index][0];
2572 level = vc1_index_decode_table[codingset][index][1];
2573 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2577 escape = decode210(gb);
2579 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2580 run = vc1_index_decode_table[codingset][index][0];
2581 level = vc1_index_decode_table[codingset][index][1];
2582 lst = index >= vc1_last_decode_table[codingset];
2585 level += vc1_last_delta_level_table[codingset][run];
2587 level += vc1_delta_level_table[codingset][run];
2590 run += vc1_last_delta_run_table[codingset][level] + 1;
2592 run += vc1_delta_run_table[codingset][level] + 1;
2598 lst = get_bits1(gb);
2599 if (v->s.esc3_level_length == 0) {
2600 if (v->pq < 8 || v->dquantfrm) { // table 59
2601 v->s.esc3_level_length = get_bits(gb, 3);
2602 if (!v->s.esc3_level_length)
2603 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2604 } else { // table 60
2605 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2607 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2609 run = get_bits(gb, v->s.esc3_run_length);
2610 sign = get_bits1(gb);
2611 level = get_bits(gb, v->s.esc3_level_length);
2622 /** Decode intra block in intra frames - should be faster than decode_intra_block
2623 * @param v VC1Context
2624 * @param block block to decode
2625 * @param[in] n subblock index
2626 * @param coded are AC coeffs present or not
2627 * @param codingset set of VLC to decode data
2629 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
2630 int coded, int codingset)
2632 GetBitContext *gb = &v->s.gb;
2633 MpegEncContext *s = &v->s;
2634 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2637 int16_t *ac_val, *ac_val2;
2640 /* Get DC differential */
2642 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2644 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2647 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2651 if (dcdiff == 119 /* ESC index value */) {
2652 /* TODO: Optimize */
2653 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2654 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2655 else dcdiff = get_bits(gb, 8);
2658 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2659 else if (v->pq == 2)
2660 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2667 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2670 /* Store the quantized DC coeff, used for prediction */
2672 block[0] = dcdiff * s->y_dc_scale;
2674 block[0] = dcdiff * s->c_dc_scale;
2685 int last = 0, skip, value;
2686 const uint8_t *zz_table;
2690 scale = v->pq * 2 + v->halfpq;
2694 zz_table = v->zz_8x8[2];
2696 zz_table = v->zz_8x8[3];
2698 zz_table = v->zz_8x8[1];
2700 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2702 if (dc_pred_dir) // left
2705 ac_val -= 16 * s->block_wrap[n];
2708 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2712 block[zz_table[i++]] = value;
2715 /* apply AC prediction if needed */
2717 if (dc_pred_dir) { // left
2718 for (k = 1; k < 8; k++)
2719 block[k << v->left_blk_sh] += ac_val[k];
2721 for (k = 1; k < 8; k++)
2722 block[k << v->top_blk_sh] += ac_val[k + 8];
2725 /* save AC coeffs for further prediction */
2726 for (k = 1; k < 8; k++) {
2727 ac_val2[k] = block[k << v->left_blk_sh];
2728 ac_val2[k + 8] = block[k << v->top_blk_sh];
2731 /* scale AC coeffs */
2732 for (k = 1; k < 64; k++)
2736 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2739 if (s->ac_pred) i = 63;
2745 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2749 scale = v->pq * 2 + v->halfpq;
2750 memset(ac_val2, 0, 16 * 2);
2751 if (dc_pred_dir) { // left
2754 memcpy(ac_val2, ac_val, 8 * 2);
2756 ac_val -= 16 * s->block_wrap[n];
2758 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2761 /* apply AC prediction if needed */
2763 if (dc_pred_dir) { //left
2764 for (k = 1; k < 8; k++) {
2765 block[k << v->left_blk_sh] = ac_val[k] * scale;
2766 if (!v->pquantizer && block[k << v->left_blk_sh])
2767 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2770 for (k = 1; k < 8; k++) {
2771 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2772 if (!v->pquantizer && block[k << v->top_blk_sh])
2773 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2779 s->block_last_index[n] = i;
2784 /** Decode intra block in intra frames - should be faster than decode_intra_block
2785 * @param v VC1Context
2786 * @param block block to decode
2787 * @param[in] n subblock number
2788 * @param coded are AC coeffs present or not
2789 * @param codingset set of VLC to decode data
2790 * @param mquant quantizer value for this macroblock
2792 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
2793 int coded, int codingset, int mquant)
2795 GetBitContext *gb = &v->s.gb;
2796 MpegEncContext *s = &v->s;
2797 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2799 int16_t *dc_val = NULL;
2800 int16_t *ac_val, *ac_val2;
2802 int a_avail = v->a_avail, c_avail = v->c_avail;
2803 int use_pred = s->ac_pred;
2806 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2808 /* Get DC differential */
2810 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2812 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2815 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2819 if (dcdiff == 119 /* ESC index value */) {
2820 /* TODO: Optimize */
2821 if (mquant == 1) dcdiff = get_bits(gb, 10);
2822 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2823 else dcdiff = get_bits(gb, 8);
2826 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2827 else if (mquant == 2)
2828 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2835 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2838 /* Store the quantized DC coeff, used for prediction */
2840 block[0] = dcdiff * s->y_dc_scale;
2842 block[0] = dcdiff * s->c_dc_scale;
2848 /* check if AC is needed at all */
2849 if (!a_avail && !c_avail)
2851 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2854 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2856 if (dc_pred_dir) // left
2859 ac_val -= 16 * s->block_wrap[n];
2861 q1 = s->current_picture.qscale_table[mb_pos];
2862 if ( dc_pred_dir && c_avail && mb_pos)
2863 q2 = s->current_picture.qscale_table[mb_pos - 1];
2864 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2865 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2866 if ( dc_pred_dir && n == 1)
2868 if (!dc_pred_dir && n == 2)
2874 int last = 0, skip, value;
2875 const uint8_t *zz_table;
2879 if (!use_pred && v->fcm == ILACE_FRAME) {
2880 zz_table = v->zzi_8x8;
2882 if (!dc_pred_dir) // top
2883 zz_table = v->zz_8x8[2];
2885 zz_table = v->zz_8x8[3];
2888 if (v->fcm != ILACE_FRAME)
2889 zz_table = v->zz_8x8[1];
2891 zz_table = v->zzi_8x8;
2895 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2899 block[zz_table[i++]] = value;
2902 /* apply AC prediction if needed */
2904 /* scale predictors if needed*/
2905 if (q2 && q1 != q2) {
2906 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2907 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2910 return AVERROR_INVALIDDATA;
2911 if (dc_pred_dir) { // left
2912 for (k = 1; k < 8; k++)
2913 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2915 for (k = 1; k < 8; k++)
2916 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2919 if (dc_pred_dir) { //left
2920 for (k = 1; k < 8; k++)
2921 block[k << v->left_blk_sh] += ac_val[k];
2923 for (k = 1; k < 8; k++)
2924 block[k << v->top_blk_sh] += ac_val[k + 8];
2928 /* save AC coeffs for further prediction */
2929 for (k = 1; k < 8; k++) {
2930 ac_val2[k ] = block[k << v->left_blk_sh];
2931 ac_val2[k + 8] = block[k << v->top_blk_sh];
2934 /* scale AC coeffs */
2935 for (k = 1; k < 64; k++)
2939 block[k] += (block[k] < 0) ? -mquant : mquant;
2942 if (use_pred) i = 63;
2943 } else { // no AC coeffs
2946 memset(ac_val2, 0, 16 * 2);
2947 if (dc_pred_dir) { // left
2949 memcpy(ac_val2, ac_val, 8 * 2);
2950 if (q2 && q1 != q2) {
2951 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2952 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2954 return AVERROR_INVALIDDATA;
2955 for (k = 1; k < 8; k++)
2956 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2961 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2962 if (q2 && q1 != q2) {
2963 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2964 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2966 return AVERROR_INVALIDDATA;
2967 for (k = 1; k < 8; k++)
2968 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2973 /* apply AC prediction if needed */
2975 if (dc_pred_dir) { // left
2976 for (k = 1; k < 8; k++) {
2977 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2978 if (!v->pquantizer && block[k << v->left_blk_sh])
2979 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2982 for (k = 1; k < 8; k++) {
2983 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2984 if (!v->pquantizer && block[k << v->top_blk_sh])
2985 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2991 s->block_last_index[n] = i;
2996 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2997 * @param v VC1Context
2998 * @param block block to decode
2999 * @param[in] n subblock index
3000 * @param coded are AC coeffs present or not
3001 * @param mquant block quantizer
3002 * @param codingset set of VLC to decode data
3004 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
3005 int coded, int mquant, int codingset)
3007 GetBitContext *gb = &v->s.gb;
3008 MpegEncContext *s = &v->s;
3009 int dc_pred_dir = 0; /* Direction of the DC prediction used */
3011 int16_t *dc_val = NULL;
3012 int16_t *ac_val, *ac_val2;
3014 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3015 int a_avail = v->a_avail, c_avail = v->c_avail;
3016 int use_pred = s->ac_pred;
3020 s->dsp.clear_block(block);
3022 /* XXX: Guard against dumb values of mquant */
3023 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
3025 /* Set DC scale - y and c use the same */
3026 s->y_dc_scale = s->y_dc_scale_table[mquant];
3027 s->c_dc_scale = s->c_dc_scale_table[mquant];
3029 /* Get DC differential */
3031 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3033 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3036 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3040 if (dcdiff == 119 /* ESC index value */) {
3041 /* TODO: Optimize */
3042 if (mquant == 1) dcdiff = get_bits(gb, 10);
3043 else if (mquant == 2) dcdiff = get_bits(gb, 9);
3044 else dcdiff = get_bits(gb, 8);
3047 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
3048 else if (mquant == 2)
3049 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
3056 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3059 /* Store the quantized DC coeff, used for prediction */
3062 block[0] = dcdiff * s->y_dc_scale;
3064 block[0] = dcdiff * s->c_dc_scale;
3070 /* check if AC is needed at all and adjust direction if needed */
3071 if (!a_avail) dc_pred_dir = 1;
3072 if (!c_avail) dc_pred_dir = 0;
3073 if (!a_avail && !c_avail) use_pred = 0;
3074 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3077 scale = mquant * 2 + v->halfpq;
3079 if (dc_pred_dir) //left
3082 ac_val -= 16 * s->block_wrap[n];
3084 q1 = s->current_picture.qscale_table[mb_pos];
3085 if (dc_pred_dir && c_avail && mb_pos)
3086 q2 = s->current_picture.qscale_table[mb_pos - 1];
3087 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3088 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3089 if ( dc_pred_dir && n == 1)
3091 if (!dc_pred_dir && n == 2)
3093 if (n == 3) q2 = q1;
3096 int last = 0, skip, value;
3100 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3104 if (v->fcm == PROGRESSIVE)
3105 block[v->zz_8x8[0][i++]] = value;
3107 if (use_pred && (v->fcm == ILACE_FRAME)) {
3108 if (!dc_pred_dir) // top
3109 block[v->zz_8x8[2][i++]] = value;
3111 block[v->zz_8x8[3][i++]] = value;
3113 block[v->zzi_8x8[i++]] = value;
3118 /* apply AC prediction if needed */
3120 /* scale predictors if needed*/
3121 if (q2 && q1 != q2) {
3122 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3123 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3126 return AVERROR_INVALIDDATA;
3127 if (dc_pred_dir) { // left
3128 for (k = 1; k < 8; k++)
3129 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3131 for (k = 1; k < 8; k++)
3132 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3135 if (dc_pred_dir) { // left
3136 for (k = 1; k < 8; k++)
3137 block[k << v->left_blk_sh] += ac_val[k];
3139 for (k = 1; k < 8; k++)
3140 block[k << v->top_blk_sh] += ac_val[k + 8];
3144 /* save AC coeffs for further prediction */
3145 for (k = 1; k < 8; k++) {
3146 ac_val2[k ] = block[k << v->left_blk_sh];
3147 ac_val2[k + 8] = block[k << v->top_blk_sh];
3150 /* scale AC coeffs */
3151 for (k = 1; k < 64; k++)
3155 block[k] += (block[k] < 0) ? -mquant : mquant;
3158 if (use_pred) i = 63;
3159 } else { // no AC coeffs
3162 memset(ac_val2, 0, 16 * 2);
3163 if (dc_pred_dir) { // left
3165 memcpy(ac_val2, ac_val, 8 * 2);
3166 if (q2 && q1 != q2) {
3167 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3168 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3170 return AVERROR_INVALIDDATA;
3171 for (k = 1; k < 8; k++)
3172 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3177 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3178 if (q2 && q1 != q2) {
3179 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3180 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3182 return AVERROR_INVALIDDATA;
3183 for (k = 1; k < 8; k++)
3184 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3189 /* apply AC prediction if needed */
3191 if (dc_pred_dir) { // left
3192 for (k = 1; k < 8; k++) {
3193 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3194 if (!v->pquantizer && block[k << v->left_blk_sh])
3195 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3198 for (k = 1; k < 8; k++) {
3199 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3200 if (!v->pquantizer && block[k << v->top_blk_sh])
3201 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3207 s->block_last_index[n] = i;
3214 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
3215 int mquant, int ttmb, int first_block,
3216 uint8_t *dst, int linesize, int skip_block,
3219 MpegEncContext *s = &v->s;
3220 GetBitContext *gb = &s->gb;
3223 int scale, off, idx, last, skip, value;
3224 int ttblk = ttmb & 7;
3227 s->dsp.clear_block(block);
3230 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)];
3232 if (ttblk == TT_4X4) {
3233 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3235 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3236 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3237 || (!v->res_rtm_flag && !first_block))) {
3238 subblkpat = decode012(gb);
3240 subblkpat ^= 3; // swap decoded pattern bits
3241 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3243 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3246 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3248 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3249 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3250 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3253 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3254 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3263 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3268 idx = v->zz_8x8[0][i++];
3270 idx = v->zzi_8x8[i++];
3271 block[idx] = value * scale;
3273 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3277 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3279 v->vc1dsp.vc1_inv_trans_8x8(block);
3280 s->dsp.add_pixels_clamped(block, dst, linesize);
3285 pat = ~subblkpat & 0xF;
3286 for (j = 0; j < 4; j++) {
3287 last = subblkpat & (1 << (3 - j));
3289 off = (j & 1) * 4 + (j & 2) * 16;
3291 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3296 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3298 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3299 block[idx + off] = value * scale;
3301 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3303 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3305 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3307 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3312 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3313 for (j = 0; j < 2; j++) {
3314 last = subblkpat & (1 << (1 - j));
3318 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3323 idx = v->zz_8x4[i++] + off;
3325 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3326 block[idx] = value * scale;
3328 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3330 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3332 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3334 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3339 pat = ~(subblkpat * 5) & 0xF;
3340 for (j = 0; j < 2; j++) {
3341 last = subblkpat & (1 << (1 - j));
3345 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3350 idx = v->zz_4x8[i++] + off;
3352 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3353 block[idx] = value * scale;
3355 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3357 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3359 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3361 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3367 *ttmb_out |= ttblk << (n * 4);
3371 /** @} */ // Macroblock group
3373 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3374 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3376 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3378 MpegEncContext *s = &v->s;
3379 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3380 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3381 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3382 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3383 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3386 if (block_num > 3) {
3387 dst = s->dest[block_num - 3];
3389 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3391 if (s->mb_y != s->end_mb_y || block_num < 2) {
3395 if (block_num > 3) {
3396 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3397 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3398 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3399 mv_stride = s->mb_stride;
3401 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3402 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3403 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3404 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3405 mv_stride = s->b8_stride;
3406 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3409 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3410 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3411 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3413 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3415 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3418 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3420 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3425 dst -= 4 * linesize;
3426 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3427 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3428 idx = (block_cbp | (block_cbp >> 2)) & 3;
3430 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3433 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3435 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3440 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3442 MpegEncContext *s = &v->s;
3443 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3444 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3445 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3446 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3447 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3450 if (block_num > 3) {
3451 dst = s->dest[block_num - 3] - 8 * linesize;
3453 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3456 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3459 if (block_num > 3) {
3460 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3461 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3462 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3464 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3465 : (mb_cbp >> ((block_num + 1) * 4));
3466 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3467 : (mb_is_intra >> ((block_num + 1) * 4));
3468 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3470 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3471 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3473 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3475 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3478 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3480 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3486 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3487 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3488 idx = (block_cbp | (block_cbp >> 1)) & 5;
3490 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3493 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3495 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3500 static void vc1_apply_p_loop_filter(VC1Context *v)
3502 MpegEncContext *s = &v->s;
3505 for (i = 0; i < 6; i++) {
3506 vc1_apply_p_v_loop_filter(v, i);
3509 /* V always precedes H, therefore we run H one MB before V;
3510 * at the end of a row, we catch up to complete the row */
3512 for (i = 0; i < 6; i++) {
3513 vc1_apply_p_h_loop_filter(v, i);
3515 if (s->mb_x == s->mb_width - 1) {
3517 ff_update_block_index(s);
3518 for (i = 0; i < 6; i++) {
3519 vc1_apply_p_h_loop_filter(v, i);
3525 /** Decode one P-frame MB
3527 static int vc1_decode_p_mb(VC1Context *v)
3529 MpegEncContext *s = &v->s;
3530 GetBitContext *gb = &s->gb;
3532 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3533 int cbp; /* cbp decoding stuff */
3534 int mqdiff, mquant; /* MB quantization */
3535 int ttmb = v->ttfrm; /* MB Transform type */
3537 int mb_has_coeffs = 1; /* last_flag */
3538 int dmv_x, dmv_y; /* Differential MV components */
3539 int index, index1; /* LUT indexes */
3540 int val, sign; /* temp values */
3541 int first_block = 1;
3543 int skipped, fourmv;
3544 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3546 mquant = v->pq; /* lossy initialization */
3548 if (v->mv_type_is_raw)
3549 fourmv = get_bits1(gb);
3551 fourmv = v->mv_type_mb_plane[mb_pos];
3553 skipped = get_bits1(gb);
3555 skipped = v->s.mbskip_table[mb_pos];
3557 if (!fourmv) { /* 1MV mode */
3559 GET_MVDATA(dmv_x, dmv_y);
3562 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3563 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3565 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3566 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3568 /* FIXME Set DC val for inter block ? */
3569 if (s->mb_intra && !mb_has_coeffs) {
3571 s->ac_pred = get_bits1(gb);
3573 } else if (mb_has_coeffs) {
3575 s->ac_pred = get_bits1(gb);
3576 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3582 s->current_picture.qscale_table[mb_pos] = mquant;
3584 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3585 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3586 VC1_TTMB_VLC_BITS, 2);
3587 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3589 for (i = 0; i < 6; i++) {
3590 s->dc_val[0][s->block_index[i]] = 0;
3592 val = ((cbp >> (5 - i)) & 1);
3593 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3594 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3596 /* check if prediction blocks A and C are available */
3597 v->a_avail = v->c_avail = 0;
3598 if (i == 2 || i == 3 || !s->first_slice_line)
3599 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3600 if (i == 1 || i == 3 || s->mb_x)
3601 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3603 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3604 (i & 4) ? v->codingset2 : v->codingset);
3605 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3607 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3609 for (j = 0; j < 64; j++)
3610 s->block[i][j] <<= 1;
3611 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3612 if (v->pq >= 9 && v->overlap) {
3614 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3616 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3618 block_cbp |= 0xF << (i << 2);
3619 block_intra |= 1 << i;
3621 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3622 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3623 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3624 block_cbp |= pat << (i << 2);
3625 if (!v->ttmbf && ttmb < 8)
3632 for (i = 0; i < 6; i++) {
3633 v->mb_type[0][s->block_index[i]] = 0;
3634 s->dc_val[0][s->block_index[i]] = 0;
3636 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3637 s->current_picture.qscale_table[mb_pos] = 0;
3638 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3641 } else { // 4MV mode
3642 if (!skipped /* unskipped MB */) {
3643 int intra_count = 0, coded_inter = 0;
3644 int is_intra[6], is_coded[6];
3646 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3647 for (i = 0; i < 6; i++) {
3648 val = ((cbp >> (5 - i)) & 1);
3649 s->dc_val[0][s->block_index[i]] = 0;
3656 GET_MVDATA(dmv_x, dmv_y);
3658 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3660 vc1_mc_4mv_luma(v, i, 0, 0);
3661 intra_count += s->mb_intra;
3662 is_intra[i] = s->mb_intra;
3663 is_coded[i] = mb_has_coeffs;
3666 is_intra[i] = (intra_count >= 3);
3670 vc1_mc_4mv_chroma(v, 0);
3671 v->mb_type[0][s->block_index[i]] = is_intra[i];
3673 coded_inter = !is_intra[i] & is_coded[i];
3675 // if there are no coded blocks then don't do anything more
3677 if (!intra_count && !coded_inter)
3680 s->current_picture.qscale_table[mb_pos] = mquant;
3681 /* test if block is intra and has pred */
3684 for (i = 0; i < 6; i++)
3686 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3687 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3693 s->ac_pred = get_bits1(gb);
3697 if (!v->ttmbf && coded_inter)
3698 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3699 for (i = 0; i < 6; i++) {
3701 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3702 s->mb_intra = is_intra[i];
3704 /* check if prediction blocks A and C are available */
3705 v->a_avail = v->c_avail = 0;
3706 if (i == 2 || i == 3 || !s->first_slice_line)
3707 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3708 if (i == 1 || i == 3 || s->mb_x)
3709 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3711 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3712 (i & 4) ? v->codingset2 : v->codingset);
3713 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3715 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3717 for (j = 0; j < 64; j++)
3718 s->block[i][j] <<= 1;
3719 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3720 (i & 4) ? s->uvlinesize : s->linesize);
3721 if (v->pq >= 9 && v->overlap) {
3723 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3725 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3727 block_cbp |= 0xF << (i << 2);
3728 block_intra |= 1 << i;
3729 } else if (is_coded[i]) {
3730 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3731 first_block, s->dest[dst_idx] + off,
3732 (i & 4) ? s->uvlinesize : s->linesize,
3733 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3735 block_cbp |= pat << (i << 2);
3736 if (!v->ttmbf && ttmb < 8)
3741 } else { // skipped MB
3743 s->current_picture.qscale_table[mb_pos] = 0;
3744 for (i = 0; i < 6; i++) {
3745 v->mb_type[0][s->block_index[i]] = 0;
3746 s->dc_val[0][s->block_index[i]] = 0;
3748 for (i = 0; i < 4; i++) {
3749 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3750 vc1_mc_4mv_luma(v, i, 0, 0);
3752 vc1_mc_4mv_chroma(v, 0);
3753 s->current_picture.qscale_table[mb_pos] = 0;
3757 v->cbp[s->mb_x] = block_cbp;
3758 v->ttblk[s->mb_x] = block_tt;
3759 v->is_intra[s->mb_x] = block_intra;
3764 /* Decode one macroblock in an interlaced frame p picture */
3766 static int vc1_decode_p_mb_intfr(VC1Context *v)
3768 MpegEncContext *s = &v->s;
3769 GetBitContext *gb = &s->gb;
3771 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3772 int cbp = 0; /* cbp decoding stuff */
3773 int mqdiff, mquant; /* MB quantization */
3774 int ttmb = v->ttfrm; /* MB Transform type */
3776 int mb_has_coeffs = 1; /* last_flag */
3777 int dmv_x, dmv_y; /* Differential MV components */
3778 int val; /* temp value */
3779 int first_block = 1;
3781 int skipped, fourmv = 0, twomv = 0;
3782 int block_cbp = 0, pat, block_tt = 0;
3783 int idx_mbmode = 0, mvbp;
3784 int stride_y, fieldtx;
3786 mquant = v->pq; /* Lossy initialization */
3789 skipped = get_bits1(gb);
3791 skipped = v->s.mbskip_table[mb_pos];
3793 if (v->fourmvswitch)
3794 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3796 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3797 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3798 /* store the motion vector type in a flag (useful later) */
3799 case MV_PMODE_INTFR_4MV:
3801 v->blk_mv_type[s->block_index[0]] = 0;
3802 v->blk_mv_type[s->block_index[1]] = 0;
3803 v->blk_mv_type[s->block_index[2]] = 0;
3804 v->blk_mv_type[s->block_index[3]] = 0;
3806 case MV_PMODE_INTFR_4MV_FIELD:
3808 v->blk_mv_type[s->block_index[0]] = 1;
3809 v->blk_mv_type[s->block_index[1]] = 1;
3810 v->blk_mv_type[s->block_index[2]] = 1;
3811 v->blk_mv_type[s->block_index[3]] = 1;
3813 case MV_PMODE_INTFR_2MV_FIELD:
3815 v->blk_mv_type[s->block_index[0]] = 1;
3816 v->blk_mv_type[s->block_index[1]] = 1;
3817 v->blk_mv_type[s->block_index[2]] = 1;
3818 v->blk_mv_type[s->block_index[3]] = 1;
3820 case MV_PMODE_INTFR_1MV:
3821 v->blk_mv_type[s->block_index[0]] = 0;
3822 v->blk_mv_type[s->block_index[1]] = 0;
3823 v->blk_mv_type[s->block_index[2]] = 0;
3824 v->blk_mv_type[s->block_index[3]] = 0;
3827 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3828 for (i = 0; i < 4; i++) {
3829 s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
3830 s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
3832 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3833 s->mb_intra = v->is_intra[s->mb_x] = 1;
3834 for (i = 0; i < 6; i++)
3835 v->mb_type[0][s->block_index[i]] = 1;
3836 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3837 mb_has_coeffs = get_bits1(gb);
3839 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3840 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3842 s->current_picture.qscale_table[mb_pos] = mquant;
3843 /* Set DC scale - y and c use the same (not sure if necessary here) */
3844 s->y_dc_scale = s->y_dc_scale_table[mquant];
3845 s->c_dc_scale = s->c_dc_scale_table[mquant];
3847 for (i = 0; i < 6; i++) {
3848 s->dc_val[0][s->block_index[i]] = 0;
3850 val = ((cbp >> (5 - i)) & 1);
3851 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3852 v->a_avail = v->c_avail = 0;
3853 if (i == 2 || i == 3 || !s->first_slice_line)
3854 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3855 if (i == 1 || i == 3 || s->mb_x)
3856 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3858 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3859 (i & 4) ? v->codingset2 : v->codingset);
3860 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3861 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3863 stride_y = s->linesize << fieldtx;
3864 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3866 stride_y = s->uvlinesize;
3869 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3873 } else { // inter MB
3874 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3876 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3877 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3878 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3880 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3881 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3882 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3885 s->mb_intra = v->is_intra[s->mb_x] = 0;
3886 for (i = 0; i < 6; i++)
3887 v->mb_type[0][s->block_index[i]] = 0;
3888 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3889 /* for all motion vector read MVDATA and motion compensate each block */
3893 for (i = 0; i < 6; i++) {
3896 val = ((mvbp >> (3 - i)) & 1);
3898 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3900 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0);
3901 vc1_mc_4mv_luma(v, i, 0, 0);
3902 } else if (i == 4) {
3903 vc1_mc_4mv_chroma4(v, 0, 0, 0);
3910 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3912 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3913 vc1_mc_4mv_luma(v, 0, 0, 0);
3914 vc1_mc_4mv_luma(v, 1, 0, 0);
3917 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3919 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3920 vc1_mc_4mv_luma(v, 2, 0, 0);
3921 vc1_mc_4mv_luma(v, 3, 0, 0);
3922 vc1_mc_4mv_chroma4(v, 0, 0, 0);
3924 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3927 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3929 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3933 GET_MQUANT(); // p. 227
3934 s->current_picture.qscale_table[mb_pos] = mquant;
3935 if (!v->ttmbf && cbp)
3936 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3937 for (i = 0; i < 6; i++) {
3938 s->dc_val[0][s->block_index[i]] = 0;
3940 val = ((cbp >> (5 - i)) & 1);
3942 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3944 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3946 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3947 first_block, s->dest[dst_idx] + off,
3948 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3949 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3950 block_cbp |= pat << (i << 2);
3951 if (!v->ttmbf && ttmb < 8)
3958 s->mb_intra = v->is_intra[s->mb_x] = 0;
3959 for (i = 0; i < 6; i++) {
3960 v->mb_type[0][s->block_index[i]] = 0;
3961 s->dc_val[0][s->block_index[i]] = 0;
3963 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3964 s->current_picture.qscale_table[mb_pos] = 0;
3965 v->blk_mv_type[s->block_index[0]] = 0;
3966 v->blk_mv_type[s->block_index[1]] = 0;
3967 v->blk_mv_type[s->block_index[2]] = 0;
3968 v->blk_mv_type[s->block_index[3]] = 0;
3969 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3972 if (s->mb_x == s->mb_width - 1)
3973 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3977 static int vc1_decode_p_mb_intfi(VC1Context *v)
3979 MpegEncContext *s = &v->s;
3980 GetBitContext *gb = &s->gb;
3982 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3983 int cbp = 0; /* cbp decoding stuff */
3984 int mqdiff, mquant; /* MB quantization */
3985 int ttmb = v->ttfrm; /* MB Transform type */
3987 int mb_has_coeffs = 1; /* last_flag */
3988 int dmv_x, dmv_y; /* Differential MV components */
3989 int val; /* temp values */
3990 int first_block = 1;
3993 int block_cbp = 0, pat, block_tt = 0;
3996 mquant = v->pq; /* Lossy initialization */
3998 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3999 if (idx_mbmode <= 1) { // intra MB
4000 s->mb_intra = v->is_intra[s->mb_x] = 1;
4001 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4002 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4003 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4005 s->current_picture.qscale_table[mb_pos] = mquant;
4006 /* Set DC scale - y and c use the same (not sure if necessary here) */
4007 s->y_dc_scale = s->y_dc_scale_table[mquant];
4008 s->c_dc_scale = s->c_dc_scale_table[mquant];
4009 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4010 mb_has_coeffs = idx_mbmode & 1;
4012 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4014 for (i = 0; i < 6; i++) {
4015 s->dc_val[0][s->block_index[i]] = 0;
4016 v->mb_type[0][s->block_index[i]] = 1;
4018 val = ((cbp >> (5 - i)) & 1);
4019 v->a_avail = v->c_avail = 0;
4020 if (i == 2 || i == 3 || !s->first_slice_line)
4021 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4022 if (i == 1 || i == 3 || s->mb_x)
4023 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4025 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4026 (i & 4) ? v->codingset2 : v->codingset);
4027 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4029 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4030 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4031 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4032 // TODO: loop filter
4035 s->mb_intra = v->is_intra[s->mb_x] = 0;
4036 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4037 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4038 if (idx_mbmode <= 5) { // 1-MV
4039 dmv_x = dmv_y = pred_flag = 0;
4040 if (idx_mbmode & 1) {
4041 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4043 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4045 mb_has_coeffs = !(idx_mbmode & 2);
4047 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4048 for (i = 0; i < 6; i++) {
4050 dmv_x = dmv_y = pred_flag = 0;
4051 val = ((v->fourmvbp >> (3 - i)) & 1);
4053 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4055 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4056 vc1_mc_4mv_luma(v, i, 0, 0);
4058 vc1_mc_4mv_chroma(v, 0);
4060 mb_has_coeffs = idx_mbmode & 1;
4063 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4067 s->current_picture.qscale_table[mb_pos] = mquant;
4068 if (!v->ttmbf && cbp) {
4069 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4072 for (i = 0; i < 6; i++) {
4073 s->dc_val[0][s->block_index[i]] = 0;
4075 val = ((cbp >> (5 - i)) & 1);
4076 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4078 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4079 first_block, s->dest[dst_idx] + off,
4080 (i & 4) ? s->uvlinesize : s->linesize,
4081 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
4083 block_cbp |= pat << (i << 2);
4084 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4089 if (s->mb_x == s->mb_width - 1)
4090 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4094 /** Decode one B-frame MB (in Main profile)
4096 static void vc1_decode_b_mb(VC1Context *v)
4098 MpegEncContext *s = &v->s;
4099 GetBitContext *gb = &s->gb;
4101 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4102 int cbp = 0; /* cbp decoding stuff */
4103 int mqdiff, mquant; /* MB quantization */
4104 int ttmb = v->ttfrm; /* MB Transform type */
4105 int mb_has_coeffs = 0; /* last_flag */
4106 int index, index1; /* LUT indexes */
4107 int val, sign; /* temp values */
4108 int first_block = 1;
4110 int skipped, direct;
4111 int dmv_x[2], dmv_y[2];
4112 int bmvtype = BMV_TYPE_BACKWARD;
4114 mquant = v->pq; /* lossy initialization */
4118 direct = get_bits1(gb);
4120 direct = v->direct_mb_plane[mb_pos];
4122 skipped = get_bits1(gb);
4124 skipped = v->s.mbskip_table[mb_pos];
4126 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4127 for (i = 0; i < 6; i++) {
4128 v->mb_type[0][s->block_index[i]] = 0;
4129 s->dc_val[0][s->block_index[i]] = 0;
4131 s->current_picture.qscale_table[mb_pos] = 0;
4135 GET_MVDATA(dmv_x[0], dmv_y[0]);
4136 dmv_x[1] = dmv_x[0];
4137 dmv_y[1] = dmv_y[0];
4139 if (skipped || !s->mb_intra) {
4140 bmvtype = decode012(gb);
4143 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4146 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4149 bmvtype = BMV_TYPE_INTERPOLATED;
4150 dmv_x[0] = dmv_y[0] = 0;
4154 for (i = 0; i < 6; i++)
4155 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4159 bmvtype = BMV_TYPE_INTERPOLATED;
4160 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4161 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4165 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4168 s->current_picture.qscale_table[mb_pos] = mquant;
4170 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4171 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4172 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4173 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4175 if (!mb_has_coeffs && !s->mb_intra) {
4176 /* no coded blocks - effectively skipped */
4177 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4178 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4181 if (s->mb_intra && !mb_has_coeffs) {
4183 s->current_picture.qscale_table[mb_pos] = mquant;
4184 s->ac_pred = get_bits1(gb);
4186 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4188 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4189 GET_MVDATA(dmv_x[0], dmv_y[0]);
4190 if (!mb_has_coeffs) {
4191 /* interpolated skipped block */
4192 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4193 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4197 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4199 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4202 s->ac_pred = get_bits1(gb);
4203 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4205 s->current_picture.qscale_table[mb_pos] = mquant;
4206 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4207 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4211 for (i = 0; i < 6; i++) {
4212 s->dc_val[0][s->block_index[i]] = 0;
4214 val = ((cbp >> (5 - i)) & 1);
4215 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4216 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4218 /* check if prediction blocks A and C are available */
4219 v->a_avail = v->c_avail = 0;
4220 if (i == 2 || i == 3 || !s->first_slice_line)
4221 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4222 if (i == 1 || i == 3 || s->mb_x)
4223 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4225 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4226 (i & 4) ? v->codingset2 : v->codingset);
4227 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4229 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4231 for (j = 0; j < 64; j++)
4232 s->block[i][j] <<= 1;
4233 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4235 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4236 first_block, s->dest[dst_idx] + off,
4237 (i & 4) ? s->uvlinesize : s->linesize,
4238 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4239 if (!v->ttmbf && ttmb < 8)
4246 /** Decode one B-frame MB (in interlaced field B picture)
4248 static void vc1_decode_b_mb_intfi(VC1Context *v)
4250 MpegEncContext *s = &v->s;
4251 GetBitContext *gb = &s->gb;
4253 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4254 int cbp = 0; /* cbp decoding stuff */
4255 int mqdiff, mquant; /* MB quantization */
4256 int ttmb = v->ttfrm; /* MB Transform type */
4257 int mb_has_coeffs = 0; /* last_flag */
4258 int val; /* temp value */
4259 int first_block = 1;
4262 int dmv_x[2], dmv_y[2], pred_flag[2];
4263 int bmvtype = BMV_TYPE_BACKWARD;
4266 mquant = v->pq; /* Lossy initialization */
4269 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4270 if (idx_mbmode <= 1) { // intra MB
4271 s->mb_intra = v->is_intra[s->mb_x] = 1;
4272 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4273 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4274 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4276 s->current_picture.qscale_table[mb_pos] = mquant;
4277 /* Set DC scale - y and c use the same (not sure if necessary here) */
4278 s->y_dc_scale = s->y_dc_scale_table[mquant];
4279 s->c_dc_scale = s->c_dc_scale_table[mquant];
4280 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4281 mb_has_coeffs = idx_mbmode & 1;
4283 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4285 for (i = 0; i < 6; i++) {
4286 s->dc_val[0][s->block_index[i]] = 0;
4288 val = ((cbp >> (5 - i)) & 1);
4289 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4290 v->a_avail = v->c_avail = 0;
4291 if (i == 2 || i == 3 || !s->first_slice_line)
4292 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4293 if (i == 1 || i == 3 || s->mb_x)
4294 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4296 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4297 (i & 4) ? v->codingset2 : v->codingset);
4298 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4300 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4302 for (j = 0; j < 64; j++)
4303 s->block[i][j] <<= 1;
4304 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4305 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4306 // TODO: yet to perform loop filter
4309 s->mb_intra = v->is_intra[s->mb_x] = 0;
4310 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4311 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4313 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4315 fwd = v->forward_mb_plane[mb_pos];
4316 if (idx_mbmode <= 5) { // 1-MV
4318 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4319 pred_flag[0] = pred_flag[1] = 0;
4321 bmvtype = BMV_TYPE_FORWARD;
4323 bmvtype = decode012(gb);
4326 bmvtype = BMV_TYPE_BACKWARD;
4329 bmvtype = BMV_TYPE_DIRECT;
4332 bmvtype = BMV_TYPE_INTERPOLATED;
4333 interpmvp = get_bits1(gb);
4336 v->bmvtype = bmvtype;
4337 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4338 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4341 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4343 if (bmvtype == BMV_TYPE_DIRECT) {
4344 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4345 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4347 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4348 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4349 mb_has_coeffs = !(idx_mbmode & 2);
4352 bmvtype = BMV_TYPE_FORWARD;
4353 v->bmvtype = bmvtype;
4354 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4355 for (i = 0; i < 6; i++) {
4357 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4358 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4359 val = ((v->fourmvbp >> (3 - i)) & 1);
4361 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4362 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4363 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4365 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4366 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD, 0);
4368 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4370 mb_has_coeffs = idx_mbmode & 1;
4373 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4377 s->current_picture.qscale_table[mb_pos] = mquant;
4378 if (!v->ttmbf && cbp) {
4379 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4382 for (i = 0; i < 6; i++) {
4383 s->dc_val[0][s->block_index[i]] = 0;
4385 val = ((cbp >> (5 - i)) & 1);
4386 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4388 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4389 first_block, s->dest[dst_idx] + off,
4390 (i & 4) ? s->uvlinesize : s->linesize,
4391 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4392 if (!v->ttmbf && ttmb < 8)
4400 /** Decode one B-frame MB (in interlaced frame B picture)
4402 static int vc1_decode_b_mb_intfr(VC1Context *v)
4404 MpegEncContext *s = &v->s;
4405 GetBitContext *gb = &s->gb;
4407 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4408 int cbp = 0; /* cbp decoding stuff */
4409 int mqdiff, mquant; /* MB quantization */
4410 int ttmb = v->ttfrm; /* MB Transform type */
4411 int mvsw = 0; /* motion vector switch */
4412 int mb_has_coeffs = 1; /* last_flag */
4413 int dmv_x, dmv_y; /* Differential MV components */
4414 int val; /* temp value */
4415 int first_block = 1;
4417 int skipped, direct, twomv = 0;
4418 int block_cbp = 0, pat, block_tt = 0;
4419 int idx_mbmode = 0, mvbp;
4420 int stride_y, fieldtx;
4421 int bmvtype = BMV_TYPE_BACKWARD;
4424 mquant = v->pq; /* Lossy initialization */
4427 skipped = get_bits1(gb);
4429 skipped = v->s.mbskip_table[mb_pos];
4432 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
4433 if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
4435 v->blk_mv_type[s->block_index[0]] = 1;
4436 v->blk_mv_type[s->block_index[1]] = 1;
4437 v->blk_mv_type[s->block_index[2]] = 1;
4438 v->blk_mv_type[s->block_index[3]] = 1;
4440 v->blk_mv_type[s->block_index[0]] = 0;
4441 v->blk_mv_type[s->block_index[1]] = 0;
4442 v->blk_mv_type[s->block_index[2]] = 0;
4443 v->blk_mv_type[s->block_index[3]] = 0;
4448 direct = get_bits1(gb);
4450 direct = v->direct_mb_plane[mb_pos];
4453 s->mv[0][0][0] = s->current_picture.motion_val[0][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 0, s->quarter_sample);
4454 s->mv[0][0][1] = s->current_picture.motion_val[0][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 0, s->quarter_sample);
4455 s->mv[1][0][0] = s->current_picture.motion_val[1][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 1, s->quarter_sample);
4456 s->mv[1][0][1] = s->current_picture.motion_val[1][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 1, s->quarter_sample);
4459 s->mv[0][2][0] = s->current_picture.motion_val[0][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 0, s->quarter_sample);
4460 s->mv[0][2][1] = s->current_picture.motion_val[0][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 0, s->quarter_sample);
4461 s->mv[1][2][0] = s->current_picture.motion_val[1][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 1, s->quarter_sample);
4462 s->mv[1][2][1] = s->current_picture.motion_val[1][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 1, s->quarter_sample);
4464 for (i = 1; i < 4; i += 2) {
4465 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
4466 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
4467 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
4468 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
4471 for (i = 1; i < 4; i++) {
4472 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
4473 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
4474 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
4475 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
4480 if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
4481 for (i = 0; i < 4; i++) {
4482 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;
4483 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;
4484 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
4485 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
4487 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4488 s->mb_intra = v->is_intra[s->mb_x] = 1;
4489 for (i = 0; i < 6; i++)
4490 v->mb_type[0][s->block_index[i]] = 1;
4491 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
4492 mb_has_coeffs = get_bits1(gb);
4494 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4495 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4497 s->current_picture.qscale_table[mb_pos] = mquant;
4498 /* Set DC scale - y and c use the same (not sure if necessary here) */
4499 s->y_dc_scale = s->y_dc_scale_table[mquant];
4500 s->c_dc_scale = s->c_dc_scale_table[mquant];
4502 for (i = 0; i < 6; i++) {
4503 s->dc_val[0][s->block_index[i]] = 0;
4505 val = ((cbp >> (5 - i)) & 1);
4506 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4507 v->a_avail = v->c_avail = 0;
4508 if (i == 2 || i == 3 || !s->first_slice_line)
4509 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4510 if (i == 1 || i == 3 || s->mb_x)
4511 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4513 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4514 (i & 4) ? v->codingset2 : v->codingset);
4515 if (i > 3 && (s->flags & CODEC_FLAG_GRAY))
4517 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4519 stride_y = s->linesize << fieldtx;
4520 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
4522 stride_y = s->uvlinesize;
4525 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
4528 s->mb_intra = v->is_intra[s->mb_x] = 0;
4530 if (skipped || !s->mb_intra) {
4531 bmvtype = decode012(gb);
4534 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4537 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4540 bmvtype = BMV_TYPE_INTERPOLATED;
4544 if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
4545 mvsw = get_bits1(gb);
4548 if (!skipped) { // inter MB
4549 mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
4551 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4553 if (bmvtype == BMV_TYPE_INTERPOLATED & twomv) {
4554 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4555 } else if (bmvtype == BMV_TYPE_INTERPOLATED | twomv) {
4556 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
4560 for (i = 0; i < 6; i++)
4561 v->mb_type[0][s->block_index[i]] = 0;
4562 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1];
4563 /* for all motion vector read MVDATA and motion compensate each block */
4567 for (i = 0; i < 4; i++) {
4568 vc1_mc_4mv_luma(v, i, 0, 0);
4569 vc1_mc_4mv_luma(v, i, 1, 1);
4571 vc1_mc_4mv_chroma4(v, 0, 0, 0);
4572 vc1_mc_4mv_chroma4(v, 1, 1, 1);
4577 } else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) {
4579 for (i = 0; i < 4; i++) {
4582 val = ((mvbp >> (3 - i)) & 1);
4584 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4586 vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4587 vc1_mc_4mv_luma(v, j, dir, dir);
4588 vc1_mc_4mv_luma(v, j+1, dir, dir);
4591 vc1_mc_4mv_chroma4(v, 0, 0, 0);
4592 vc1_mc_4mv_chroma4(v, 1, 1, 1);
4593 } else if (bmvtype == BMV_TYPE_INTERPOLATED) {
4597 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4599 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4604 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4606 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4609 dir = bmvtype == BMV_TYPE_BACKWARD;
4616 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4617 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4621 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4622 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir2);
4625 for (i = 0; i < 2; i++) {
4626 s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];
4627 s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];
4628 s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];
4629 s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];
4632 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4633 vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4636 vc1_mc_4mv_luma(v, 0, dir, 0);
4637 vc1_mc_4mv_luma(v, 1, dir, 0);
4638 vc1_mc_4mv_luma(v, 2, dir2, 0);
4639 vc1_mc_4mv_luma(v, 3, dir2, 0);
4640 vc1_mc_4mv_chroma4(v, dir, dir2, 0);
4642 dir = bmvtype == BMV_TYPE_BACKWARD;
4644 mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2];
4647 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4649 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4650 v->blk_mv_type[s->block_index[0]] = 1;
4651 v->blk_mv_type[s->block_index[1]] = 1;
4652 v->blk_mv_type[s->block_index[2]] = 1;
4653 v->blk_mv_type[s->block_index[3]] = 1;
4654 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4655 for (i = 0; i < 2; i++) {
4656 s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];
4657 s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];
4663 GET_MQUANT(); // p. 227
4664 s->current_picture.qscale_table[mb_pos] = mquant;
4665 if (!v->ttmbf && cbp)
4666 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4667 for (i = 0; i < 6; i++) {
4668 s->dc_val[0][s->block_index[i]] = 0;
4670 val = ((cbp >> (5 - i)) & 1);
4672 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4674 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
4676 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4677 first_block, s->dest[dst_idx] + off,
4678 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
4679 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
4680 block_cbp |= pat << (i << 2);
4681 if (!v->ttmbf && ttmb < 8)
4689 for (i = 0; i < 6; i++) {
4690 v->mb_type[0][s->block_index[i]] = 0;
4691 s->dc_val[0][s->block_index[i]] = 0;
4693 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
4694 s->current_picture.qscale_table[mb_pos] = 0;
4695 v->blk_mv_type[s->block_index[0]] = 0;
4696 v->blk_mv_type[s->block_index[1]] = 0;
4697 v->blk_mv_type[s->block_index[2]] = 0;
4698 v->blk_mv_type[s->block_index[3]] = 0;
4701 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4702 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4703 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4705 dir = bmvtype == BMV_TYPE_BACKWARD;
4706 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4711 for (i = 0; i < 2; i++) {
4712 s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];
4713 s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];
4714 s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];
4715 s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];
4718 v->blk_mv_type[s->block_index[0]] = 1;
4719 v->blk_mv_type[s->block_index[1]] = 1;
4720 v->blk_mv_type[s->block_index[2]] = 1;
4721 v->blk_mv_type[s->block_index[3]] = 1;
4722 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4723 for (i = 0; i < 2; i++) {
4724 s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];
4725 s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];
4732 if (direct || bmvtype == BMV_TYPE_INTERPOLATED) {
4737 if (s->mb_x == s->mb_width - 1)
4738 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4739 v->cbp[s->mb_x] = block_cbp;
4740 v->ttblk[s->mb_x] = block_tt;
4744 /** Decode blocks of I-frame
4746 static void vc1_decode_i_blocks(VC1Context *v)
4749 MpegEncContext *s = &v->s;
4754 /* select codingmode used for VLC tables selection */
4755 switch (v->y_ac_table_index) {
4757 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4760 v->codingset = CS_HIGH_MOT_INTRA;
4763 v->codingset = CS_MID_RATE_INTRA;
4767 switch (v->c_ac_table_index) {
4769 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4772 v->codingset2 = CS_HIGH_MOT_INTER;
4775 v->codingset2 = CS_MID_RATE_INTER;
4779 /* Set DC scale - y and c use the same */
4780 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4781 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4784 s->mb_x = s->mb_y = 0;
4786 s->first_slice_line = 1;
4787 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4789 init_block_index(v);
4790 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4792 ff_update_block_index(s);
4793 dst[0] = s->dest[0];
4794 dst[1] = dst[0] + 8;
4795 dst[2] = s->dest[0] + s->linesize * 8;
4796 dst[3] = dst[2] + 8;
4797 dst[4] = s->dest[1];
4798 dst[5] = s->dest[2];
4799 s->dsp.clear_blocks(s->block[0]);
4800 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4801 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4802 s->current_picture.qscale_table[mb_pos] = v->pq;
4803 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4804 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4806 // do actual MB decoding and displaying
4807 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4808 v->s.ac_pred = get_bits1(&v->s.gb);
4810 for (k = 0; k < 6; k++) {
4811 val = ((cbp >> (5 - k)) & 1);
4814 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4818 cbp |= val << (5 - k);
4820 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4822 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4824 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4825 if (v->pq >= 9 && v->overlap) {
4827 for (j = 0; j < 64; j++)
4828 s->block[k][j] <<= 1;
4829 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4832 for (j = 0; j < 64; j++)
4833 s->block[k][j] = (s->block[k][j] - 64) << 1;
4834 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4838 if (v->pq >= 9 && v->overlap) {
4840 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4841 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4842 if (!(s->flags & CODEC_FLAG_GRAY)) {
4843 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4844 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4847 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4848 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4849 if (!s->first_slice_line) {
4850 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4851 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4852 if (!(s->flags & CODEC_FLAG_GRAY)) {
4853 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4854 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4857 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4858 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4860 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4862 if (get_bits_count(&s->gb) > v->bits) {
4863 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4864 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4865 get_bits_count(&s->gb), v->bits);
4869 if (!v->s.loop_filter)
4870 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4872 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4874 s->first_slice_line = 0;
4876 if (v->s.loop_filter)
4877 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4879 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4880 * profile, these only differ are when decoding MSS2 rectangles. */
4881 ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4884 /** Decode blocks of I-frame for advanced profile
4886 static void vc1_decode_i_blocks_adv(VC1Context *v)
4889 MpegEncContext *s = &v->s;
4895 GetBitContext *gb = &s->gb;
4897 /* select codingmode used for VLC tables selection */
4898 switch (v->y_ac_table_index) {
4900 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4903 v->codingset = CS_HIGH_MOT_INTRA;
4906 v->codingset = CS_MID_RATE_INTRA;
4910 switch (v->c_ac_table_index) {
4912 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4915 v->codingset2 = CS_HIGH_MOT_INTER;
4918 v->codingset2 = CS_MID_RATE_INTER;
4923 s->mb_x = s->mb_y = 0;
4925 s->first_slice_line = 1;
4926 s->mb_y = s->start_mb_y;
4927 if (s->start_mb_y) {
4929 init_block_index(v);
4930 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4931 (1 + s->b8_stride) * sizeof(*s->coded_block));
4933 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4935 init_block_index(v);
4936 for (;s->mb_x < s->mb_width; s->mb_x++) {
4937 int16_t (*block)[64] = v->block[v->cur_blk_idx];
4938 ff_update_block_index(s);
4939 s->dsp.clear_blocks(block[0]);
4940 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4941 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4942 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4943 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4945 // do actual MB decoding and displaying
4946 if (v->fieldtx_is_raw)
4947 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4948 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4949 if ( v->acpred_is_raw)
4950 v->s.ac_pred = get_bits1(&v->s.gb);
4952 v->s.ac_pred = v->acpred_plane[mb_pos];
4954 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4955 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4959 s->current_picture.qscale_table[mb_pos] = mquant;
4960 /* Set DC scale - y and c use the same */
4961 s->y_dc_scale = s->y_dc_scale_table[mquant];
4962 s->c_dc_scale = s->c_dc_scale_table[mquant];
4964 for (k = 0; k < 6; k++) {
4965 val = ((cbp >> (5 - k)) & 1);
4968 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4972 cbp |= val << (5 - k);
4974 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4975 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4977 vc1_decode_i_block_adv(v, block[k], k, val,
4978 (k < 4) ? v->codingset : v->codingset2, mquant);
4980 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4982 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4985 vc1_smooth_overlap_filter_iblk(v);
4986 vc1_put_signed_blocks_clamped(v);
4987 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4989 if (get_bits_count(&s->gb) > v->bits) {
4990 // TODO: may need modification to handle slice coding
4991 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4992 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4993 get_bits_count(&s->gb), v->bits);
4997 if (!v->s.loop_filter)
4998 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5000 ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
5001 s->first_slice_line = 0;
5004 /* raw bottom MB row */
5006 init_block_index(v);
5008 for (;s->mb_x < s->mb_width; s->mb_x++) {
5009 ff_update_block_index(s);
5010 vc1_put_signed_blocks_clamped(v);
5011 if (v->s.loop_filter)
5012 vc1_loop_filter_iblk_delayed(v, v->pq);
5014 if (v->s.loop_filter)
5015 ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
5016 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5017 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5020 static void vc1_decode_p_blocks(VC1Context *v)
5022 MpegEncContext *s = &v->s;
5023 int apply_loop_filter;
5025 /* select codingmode used for VLC tables selection */
5026 switch (v->c_ac_table_index) {
5028 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5031 v->codingset = CS_HIGH_MOT_INTRA;
5034 v->codingset = CS_MID_RATE_INTRA;
5038 switch (v->c_ac_table_index) {
5040 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5043 v->codingset2 = CS_HIGH_MOT_INTER;
5046 v->codingset2 = CS_MID_RATE_INTER;
5050 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY) &&
5051 v->fcm == PROGRESSIVE;
5052 s->first_slice_line = 1;
5053 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
5054 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5056 init_block_index(v);
5057 for (; s->mb_x < s->mb_width; s->mb_x++) {
5058 ff_update_block_index(s);
5060 if (v->fcm == ILACE_FIELD)
5061 vc1_decode_p_mb_intfi(v);
5062 else if (v->fcm == ILACE_FRAME)
5063 vc1_decode_p_mb_intfr(v);
5064 else vc1_decode_p_mb(v);
5065 if (s->mb_y != s->start_mb_y && apply_loop_filter)
5066 vc1_apply_p_loop_filter(v);
5067 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5068 // TODO: may need modification to handle slice coding
5069 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5070 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5071 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5075 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
5076 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
5077 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
5078 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
5079 if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5080 s->first_slice_line = 0;
5082 if (apply_loop_filter) {
5084 init_block_index(v);
5085 for (; s->mb_x < s->mb_width; s->mb_x++) {
5086 ff_update_block_index(s);
5087 vc1_apply_p_loop_filter(v);
5090 if (s->end_mb_y >= s->start_mb_y)
5091 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5092 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5093 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5096 static void vc1_decode_b_blocks(VC1Context *v)
5098 MpegEncContext *s = &v->s;
5100 /* select codingmode used for VLC tables selection */
5101 switch (v->c_ac_table_index) {
5103 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5106 v->codingset = CS_HIGH_MOT_INTRA;
5109 v->codingset = CS_MID_RATE_INTRA;
5113 switch (v->c_ac_table_index) {
5115 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5118 v->codingset2 = CS_HIGH_MOT_INTER;
5121 v->codingset2 = CS_MID_RATE_INTER;
5125 s->first_slice_line = 1;
5126 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5128 init_block_index(v);
5129 for (; s->mb_x < s->mb_width; s->mb_x++) {
5130 ff_update_block_index(s);
5132 if (v->fcm == ILACE_FIELD)
5133 vc1_decode_b_mb_intfi(v);
5134 else if (v->fcm == ILACE_FRAME)
5135 vc1_decode_b_mb_intfr(v);
5138 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5139 // TODO: may need modification to handle slice coding
5140 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5141 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5142 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5145 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
5147 if (!v->s.loop_filter)
5148 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5150 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5151 s->first_slice_line = 0;
5153 if (v->s.loop_filter)
5154 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5155 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5156 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5159 static void vc1_decode_skip_blocks(VC1Context *v)
5161 MpegEncContext *s = &v->s;
5163 if (!v->s.last_picture.f.data[0])
5166 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
5167 s->first_slice_line = 1;
5168 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5170 init_block_index(v);
5171 ff_update_block_index(s);
5172 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
5173 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5174 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5175 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5176 s->first_slice_line = 0;
5178 s->pict_type = AV_PICTURE_TYPE_P;
5181 void ff_vc1_decode_blocks(VC1Context *v)
5184 v->s.esc3_level_length = 0;
5186 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
5189 v->left_blk_idx = -1;
5190 v->topleft_blk_idx = 1;
5192 switch (v->s.pict_type) {
5193 case AV_PICTURE_TYPE_I:
5194 if (v->profile == PROFILE_ADVANCED)
5195 vc1_decode_i_blocks_adv(v);
5197 vc1_decode_i_blocks(v);
5199 case AV_PICTURE_TYPE_P:
5200 if (v->p_frame_skipped)
5201 vc1_decode_skip_blocks(v);
5203 vc1_decode_p_blocks(v);
5205 case AV_PICTURE_TYPE_B:
5207 if (v->profile == PROFILE_ADVANCED)
5208 vc1_decode_i_blocks_adv(v);
5210 vc1_decode_i_blocks(v);
5212 vc1_decode_b_blocks(v);
5218 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5222 * Transform coefficients for both sprites in 16.16 fixed point format,
5223 * in the order they appear in the bitstream:
5225 * rotation 1 (unused)
5227 * rotation 2 (unused)
5234 int effect_type, effect_flag;
5235 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
5236 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
5239 static inline int get_fp_val(GetBitContext* gb)
5241 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
5244 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
5248 switch (get_bits(gb, 2)) {
5251 c[2] = get_fp_val(gb);
5255 c[0] = c[4] = get_fp_val(gb);
5256 c[2] = get_fp_val(gb);
5259 c[0] = get_fp_val(gb);
5260 c[2] = get_fp_val(gb);
5261 c[4] = get_fp_val(gb);
5264 c[0] = get_fp_val(gb);
5265 c[1] = get_fp_val(gb);
5266 c[2] = get_fp_val(gb);
5267 c[3] = get_fp_val(gb);
5268 c[4] = get_fp_val(gb);
5271 c[5] = get_fp_val(gb);
5273 c[6] = get_fp_val(gb);
5278 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
5280 AVCodecContext *avctx = v->s.avctx;
5283 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5284 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
5285 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
5286 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
5287 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
5288 for (i = 0; i < 7; i++)
5289 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
5290 sd->coefs[sprite][i] / (1<<16),
5291 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
5292 av_log(avctx, AV_LOG_DEBUG, "\n");
5296 if (sd->effect_type = get_bits_long(gb, 30)) {
5297 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
5299 vc1_sprite_parse_transform(gb, sd->effect_params1);
5302 vc1_sprite_parse_transform(gb, sd->effect_params1);
5303 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
5306 for (i = 0; i < sd->effect_pcount1; i++)
5307 sd->effect_params1[i] = get_fp_val(gb);
5309 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
5310 // effect 13 is simple alpha blending and matches the opacity above
5311 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
5312 for (i = 0; i < sd->effect_pcount1; i++)
5313 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5314 sd->effect_params1[i] / (1 << 16),
5315 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
5316 av_log(avctx, AV_LOG_DEBUG, "\n");
5319 sd->effect_pcount2 = get_bits(gb, 16);
5320 if (sd->effect_pcount2 > 10) {
5321 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
5323 } else if (sd->effect_pcount2) {
5325 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
5326 while (++i < sd->effect_pcount2) {
5327 sd->effect_params2[i] = get_fp_val(gb);
5328 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5329 sd->effect_params2[i] / (1 << 16),
5330 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
5332 av_log(avctx, AV_LOG_DEBUG, "\n");
5335 if (sd->effect_flag = get_bits1(gb))
5336 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
5338 if (get_bits_count(gb) >= gb->size_in_bits +
5339 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
5340 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
5341 if (get_bits_count(gb) < gb->size_in_bits - 8)
5342 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
5345 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
5347 int i, plane, row, sprite;
5348 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
5349 uint8_t* src_h[2][2];
5350 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
5352 MpegEncContext *s = &v->s;
5354 for (i = 0; i < 2; i++) {
5355 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
5356 xadv[i] = sd->coefs[i][0];
5357 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
5358 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
5360 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
5361 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
5363 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
5365 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
5366 int width = v->output_width>>!!plane;
5368 for (row = 0; row < v->output_height>>!!plane; row++) {
5369 uint8_t *dst = v->sprite_output_frame.data[plane] +
5370 v->sprite_output_frame.linesize[plane] * row;
5372 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5373 uint8_t *iplane = s->current_picture.f.data[plane];
5374 int iline = s->current_picture.f.linesize[plane];
5375 int ycoord = yoff[sprite] + yadv[sprite] * row;
5376 int yline = ycoord >> 16;
5378 ysub[sprite] = ycoord & 0xFFFF;
5380 iplane = s->last_picture.f.data[plane];
5381 iline = s->last_picture.f.linesize[plane];
5383 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
5384 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
5385 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
5387 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
5389 if (sr_cache[sprite][0] != yline) {
5390 if (sr_cache[sprite][1] == yline) {
5391 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
5392 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
5394 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
5395 sr_cache[sprite][0] = yline;
5398 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
5399 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
5400 iplane + next_line, xoff[sprite],
5401 xadv[sprite], width);
5402 sr_cache[sprite][1] = yline + 1;
5404 src_h[sprite][0] = v->sr_rows[sprite][0];
5405 src_h[sprite][1] = v->sr_rows[sprite][1];
5409 if (!v->two_sprites) {
5411 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
5413 memcpy(dst, src_h[0][0], width);
5416 if (ysub[0] && ysub[1]) {
5417 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5418 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5419 } else if (ysub[0]) {
5420 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5421 src_h[1][0], alpha, width);
5422 } else if (ysub[1]) {
5423 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5424 src_h[0][0], (1<<16)-1-alpha, width);
5426 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5432 for (i = 0; i < 2; i++) {
5442 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5445 MpegEncContext *s = &v->s;
5446 AVCodecContext *avctx = s->avctx;
5449 vc1_parse_sprites(v, gb, &sd);
5451 if (!s->current_picture.f.data[0]) {
5452 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5456 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5457 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5461 av_frame_unref(&v->sprite_output_frame);
5462 if ((ret = ff_get_buffer(avctx, &v->sprite_output_frame, 0)) < 0)
5465 vc1_draw_sprites(v, &sd);
5470 static void vc1_sprite_flush(AVCodecContext *avctx)
5472 VC1Context *v = avctx->priv_data;
5473 MpegEncContext *s = &v->s;
5474 AVFrame *f = &s->current_picture.f;
5477 /* Windows Media Image codecs have a convergence interval of two keyframes.
5478 Since we can't enforce it, clear to black the missing sprite. This is
5479 wrong but it looks better than doing nothing. */
5482 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5483 for (i = 0; i < v->sprite_height>>!!plane; i++)
5484 memset(f->data[plane] + i * f->linesize[plane],
5485 plane ? 128 : 0, f->linesize[plane]);
5490 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5492 MpegEncContext *s = &v->s;
5495 /* Allocate mb bitplanes */
5496 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5497 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5498 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5499 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5500 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5501 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5503 v->n_allocated_blks = s->mb_width + 2;
5504 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5505 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5506 v->cbp = v->cbp_base + s->mb_stride;
5507 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5508 v->ttblk = v->ttblk_base + s->mb_stride;
5509 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5510 v->is_intra = v->is_intra_base + s->mb_stride;
5511 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5512 v->luma_mv = v->luma_mv_base + s->mb_stride;
5514 /* allocate block type info in that way so it could be used with s->block_index[] */
5515 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5516 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5517 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5518 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5520 /* allocate memory to store block level MV info */
5521 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5522 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5523 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5524 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5525 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5526 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5527 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5528 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);
5530 /* Init coded blocks info */
5531 if (v->profile == PROFILE_ADVANCED) {
5532 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5534 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5538 ff_intrax8_common_init(&v->x8,s);
5540 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5541 for (i = 0; i < 4; i++)
5542 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
5543 return AVERROR(ENOMEM);
5546 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5547 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5549 av_freep(&v->mv_type_mb_plane);
5550 av_freep(&v->direct_mb_plane);
5551 av_freep(&v->acpred_plane);
5552 av_freep(&v->over_flags_plane);
5553 av_freep(&v->block);
5554 av_freep(&v->cbp_base);
5555 av_freep(&v->ttblk_base);
5556 av_freep(&v->is_intra_base);
5557 av_freep(&v->luma_mv_base);
5558 av_freep(&v->mb_type_base);
5559 return AVERROR(ENOMEM);
5565 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5568 for (i = 0; i < 64; i++) {
5569 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5570 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5571 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5572 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5573 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5574 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5580 /** Initialize a VC1/WMV3 decoder
5581 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5582 * @todo TODO: Decypher remaining bits in extra_data
5584 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5586 VC1Context *v = avctx->priv_data;
5587 MpegEncContext *s = &v->s;
5591 /* save the container output size for WMImage */
5592 v->output_width = avctx->width;
5593 v->output_height = avctx->height;
5595 if (!avctx->extradata_size || !avctx->extradata)
5597 if (!(avctx->flags & CODEC_FLAG_GRAY))
5598 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5600 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5601 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5603 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5604 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5606 if ((ret = ff_vc1_init_common(v)) < 0)
5608 // ensure static VLC tables are initialized
5609 if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
5611 if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
5613 // Hack to ensure the above functions will be called
5614 // again once we know all necessary settings.
5615 // That this is necessary might indicate a bug.
5616 ff_vc1_decode_end(avctx);
5618 ff_h264chroma_init(&v->h264chroma, 8);
5619 ff_vc1dsp_init(&v->vc1dsp);
5621 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5624 // looks like WMV3 has a sequence header stored in the extradata
5625 // advanced sequence header may be before the first frame
5626 // the last byte of the extradata is a version number, 1 for the
5627 // samples we can decode
5629 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5631 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
5634 count = avctx->extradata_size*8 - get_bits_count(&gb);
5636 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5637 count, get_bits(&gb, count));
5638 } else if (count < 0) {
5639 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5641 } else { // VC1/WVC1/WVP2
5642 const uint8_t *start = avctx->extradata;
5643 uint8_t *end = avctx->extradata + avctx->extradata_size;
5644 const uint8_t *next;
5645 int size, buf2_size;
5646 uint8_t *buf2 = NULL;
5647 int seq_initialized = 0, ep_initialized = 0;
5649 if (avctx->extradata_size < 16) {
5650 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5654 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5655 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5657 for (; next < end; start = next) {
5658 next = find_next_marker(start + 4, end);
5659 size = next - start - 4;
5662 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5663 init_get_bits(&gb, buf2, buf2_size * 8);
5664 switch (AV_RB32(start)) {
5665 case VC1_CODE_SEQHDR:
5666 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
5670 seq_initialized = 1;
5672 case VC1_CODE_ENTRYPOINT:
5673 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
5682 if (!seq_initialized || !ep_initialized) {
5683 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5686 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5689 avctx->profile = v->profile;
5690 if (v->profile == PROFILE_ADVANCED)
5691 avctx->level = v->level;
5693 avctx->has_b_frames = !!avctx->max_b_frames;
5695 s->mb_width = (avctx->coded_width + 15) >> 4;
5696 s->mb_height = (avctx->coded_height + 15) >> 4;
5698 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5699 ff_vc1_init_transposed_scantables(v);
5701 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5706 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5707 v->sprite_width = avctx->coded_width;
5708 v->sprite_height = avctx->coded_height;
5710 avctx->coded_width = avctx->width = v->output_width;
5711 avctx->coded_height = avctx->height = v->output_height;
5713 // prevent 16.16 overflows
5714 if (v->sprite_width > 1 << 14 ||
5715 v->sprite_height > 1 << 14 ||
5716 v->output_width > 1 << 14 ||
5717 v->output_height > 1 << 14) return -1;
5719 if ((v->sprite_width&1) || (v->sprite_height&1)) {
5720 avpriv_request_sample(avctx, "odd sprites support");
5721 return AVERROR_PATCHWELCOME;
5727 /** Close a VC1/WMV3 decoder
5728 * @warning Initial try at using MpegEncContext stuff
5730 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5732 VC1Context *v = avctx->priv_data;
5735 av_frame_unref(&v->sprite_output_frame);
5737 for (i = 0; i < 4; i++)
5738 av_freep(&v->sr_rows[i >> 1][i & 1]);
5739 av_freep(&v->hrd_rate);
5740 av_freep(&v->hrd_buffer);
5741 ff_MPV_common_end(&v->s);
5742 av_freep(&v->mv_type_mb_plane);
5743 av_freep(&v->direct_mb_plane);
5744 av_freep(&v->forward_mb_plane);
5745 av_freep(&v->fieldtx_plane);
5746 av_freep(&v->acpred_plane);
5747 av_freep(&v->over_flags_plane);
5748 av_freep(&v->mb_type_base);
5749 av_freep(&v->blk_mv_type_base);
5750 av_freep(&v->mv_f_base);
5751 av_freep(&v->mv_f_next_base);
5752 av_freep(&v->block);
5753 av_freep(&v->cbp_base);
5754 av_freep(&v->ttblk_base);
5755 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5756 av_freep(&v->luma_mv_base);
5757 ff_intrax8_common_end(&v->x8);
5762 /** Decode a VC1/WMV3 frame
5763 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5765 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5766 int *got_frame, AVPacket *avpkt)
5768 const uint8_t *buf = avpkt->data;
5769 int buf_size = avpkt->size, n_slices = 0, i, ret;
5770 VC1Context *v = avctx->priv_data;
5771 MpegEncContext *s = &v->s;
5772 AVFrame *pict = data;
5773 uint8_t *buf2 = NULL;
5774 const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
5775 int mb_height, n_slices1=-1;
5780 } *slices = NULL, *tmp;
5782 v->second_field = 0;
5784 if(s->flags & CODEC_FLAG_LOW_DELAY)
5787 /* no supplementary picture */
5788 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5789 /* special case for last picture */
5790 if (s->low_delay == 0 && s->next_picture_ptr) {
5791 if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
5793 s->next_picture_ptr = NULL;
5801 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5802 if (v->profile < PROFILE_ADVANCED)
5803 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5805 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5808 //for advanced profile we may need to parse and unescape data
5809 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5811 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5813 return AVERROR(ENOMEM);
5815 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5816 const uint8_t *start, *end, *next;
5820 for (start = buf, end = buf + buf_size; next < end; start = next) {
5821 next = find_next_marker(start + 4, end);
5822 size = next - start - 4;
5823 if (size <= 0) continue;
5824 switch (AV_RB32(start)) {
5825 case VC1_CODE_FRAME:
5826 if (avctx->hwaccel ||
5827 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5829 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5831 case VC1_CODE_FIELD: {
5833 if (avctx->hwaccel ||
5834 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5835 buf_start_second_field = start;
5836 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5840 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5841 if (!slices[n_slices].buf)
5843 buf_size3 = vc1_unescape_buffer(start + 4, size,
5844 slices[n_slices].buf);
5845 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5847 /* assuming that the field marker is at the exact middle,
5848 hope it's correct */
5849 slices[n_slices].mby_start = s->mb_height >> 1;
5850 n_slices1 = n_slices - 1; // index of the last slice of the first field
5854 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5855 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5856 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5857 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5859 case VC1_CODE_SLICE: {
5861 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5865 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5866 if (!slices[n_slices].buf)
5868 buf_size3 = vc1_unescape_buffer(start + 4, size,
5869 slices[n_slices].buf);
5870 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5872 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5878 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5879 const uint8_t *divider;
5882 divider = find_next_marker(buf, buf + buf_size);
5883 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5884 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5886 } else { // found field marker, unescape second field
5887 if (avctx->hwaccel ||
5888 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5889 buf_start_second_field = divider;
5890 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5894 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5895 if (!slices[n_slices].buf)
5897 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5898 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5900 slices[n_slices].mby_start = s->mb_height >> 1;
5901 n_slices1 = n_slices - 1;
5904 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5906 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5908 init_get_bits(&s->gb, buf2, buf_size2*8);
5910 init_get_bits(&s->gb, buf, buf_size*8);
5912 if (v->res_sprite) {
5913 v->new_sprite = !get_bits1(&s->gb);
5914 v->two_sprites = get_bits1(&s->gb);
5915 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5916 we're using the sprite compositor. These are intentionally kept separate
5917 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5918 the vc1 one for WVP2 */
5919 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5920 if (v->new_sprite) {
5921 // switch AVCodecContext parameters to those of the sprites
5922 avctx->width = avctx->coded_width = v->sprite_width;
5923 avctx->height = avctx->coded_height = v->sprite_height;
5930 if (s->context_initialized &&
5931 (s->width != avctx->coded_width ||
5932 s->height != avctx->coded_height)) {
5933 ff_vc1_decode_end(avctx);
5936 if (!s->context_initialized) {
5937 if (ff_msmpeg4_decode_init(avctx) < 0)
5939 if (ff_vc1_decode_init_alloc_tables(v) < 0) {
5940 ff_MPV_common_end(s);
5944 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5946 if (v->profile == PROFILE_ADVANCED) {
5947 if(avctx->coded_width<=1 || avctx->coded_height<=1)
5949 s->h_edge_pos = avctx->coded_width;
5950 s->v_edge_pos = avctx->coded_height;
5954 /* We need to set current_picture_ptr before reading the header,
5955 * otherwise we cannot store anything in there. */
5956 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5957 int i = ff_find_unused_picture(s, 0);
5960 s->current_picture_ptr = &s->picture[i];
5963 // do parse frame header
5964 v->pic_header_flag = 0;
5965 v->first_pic_header_flag = 1;
5966 if (v->profile < PROFILE_ADVANCED) {
5967 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5971 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5975 v->first_pic_header_flag = 0;
5977 if (avctx->debug & FF_DEBUG_PICT_INFO)
5978 av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
5980 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5981 && s->pict_type != AV_PICTURE_TYPE_I) {
5982 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5986 if ((s->mb_height >> v->field_mode) == 0) {
5987 av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
5991 // process pulldown flags
5992 s->current_picture_ptr->f.repeat_pict = 0;
5993 // Pulldown flags are only valid when 'broadcast' has been set.
5994 // So ticks_per_frame will be 2
5997 s->current_picture_ptr->f.repeat_pict = 1;
5998 } else if (v->rptfrm) {
6000 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
6003 // for skipping the frame
6004 s->current_picture.f.pict_type = s->pict_type;
6005 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
6007 /* skip B-frames if we don't have reference frames */
6008 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
6011 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
6012 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
6013 avctx->skip_frame >= AVDISCARD_ALL) {
6017 if (s->next_p_frame_damaged) {
6018 if (s->pict_type == AV_PICTURE_TYPE_B)
6021 s->next_p_frame_damaged = 0;
6024 if (ff_MPV_frame_start(s, avctx) < 0) {
6028 v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
6029 v->s.current_picture_ptr->f.top_field_first = v->tff;
6031 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
6032 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
6034 if ((CONFIG_VC1_VDPAU_DECODER)
6035 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
6036 if (v->field_mode && buf_start_second_field) {
6037 ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
6038 ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
6040 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
6042 } else if (avctx->hwaccel) {
6043 if (v->field_mode && buf_start_second_field) {
6044 // decode first field
6045 s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
6046 if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6048 if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6050 if (avctx->hwaccel->end_frame(avctx) < 0)
6053 // decode second field
6054 s->gb = slices[n_slices1 + 1].gb;
6055 s->picture_structure = PICT_TOP_FIELD + v->tff;
6056 v->second_field = 1;
6057 v->pic_header_flag = 0;
6058 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
6059 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
6062 v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
6064 if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6066 if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6068 if (avctx->hwaccel->end_frame(avctx) < 0)
6071 s->picture_structure = PICT_FRAME;
6072 if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6074 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6076 if (avctx->hwaccel->end_frame(avctx) < 0)
6082 ff_mpeg_er_frame_start(s);
6084 v->bits = buf_size * 8;
6085 v->end_mb_x = s->mb_width;
6086 if (v->field_mode) {
6087 s->current_picture.f.linesize[0] <<= 1;
6088 s->current_picture.f.linesize[1] <<= 1;
6089 s->current_picture.f.linesize[2] <<= 1;
6091 s->uvlinesize <<= 1;
6093 mb_height = s->mb_height >> v->field_mode;
6095 av_assert0 (mb_height > 0);
6097 for (i = 0; i <= n_slices; i++) {
6098 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
6099 if (v->field_mode <= 0) {
6100 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
6101 "picture boundary (%d >= %d)\n", i,
6102 slices[i - 1].mby_start, mb_height);
6105 v->second_field = 1;
6106 v->blocks_off = s->b8_stride * (s->mb_height&~1);
6107 v->mb_off = s->mb_stride * s->mb_height >> 1;
6109 v->second_field = 0;
6114 v->pic_header_flag = 0;
6115 if (v->field_mode && i == n_slices1 + 2) {
6116 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6117 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
6118 if (avctx->err_recognition & AV_EF_EXPLODE)
6122 } else if (get_bits1(&s->gb)) {
6123 v->pic_header_flag = 1;
6124 if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6125 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
6126 if (avctx->err_recognition & AV_EF_EXPLODE)
6134 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
6135 if (!v->field_mode || v->second_field)
6136 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6138 if (i >= n_slices) {
6139 av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
6142 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6144 if (s->end_mb_y <= s->start_mb_y) {
6145 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
6148 if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
6149 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
6152 ff_vc1_decode_blocks(v);
6154 s->gb = slices[i].gb;
6156 if (v->field_mode) {
6157 v->second_field = 0;
6158 s->current_picture.f.linesize[0] >>= 1;
6159 s->current_picture.f.linesize[1] >>= 1;
6160 s->current_picture.f.linesize[2] >>= 1;
6162 s->uvlinesize >>= 1;
6163 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
6164 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
6165 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
6168 av_dlog(s->avctx, "Consumed %i/%i bits\n",
6169 get_bits_count(&s->gb), s->gb.size_in_bits);
6170 // if (get_bits_count(&s->gb) > buf_size * 8)
6172 if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
6175 ff_er_frame_end(&s->er);
6178 ff_MPV_frame_end(s);
6180 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
6182 avctx->width = avctx->coded_width = v->output_width;
6183 avctx->height = avctx->coded_height = v->output_height;
6184 if (avctx->skip_frame >= AVDISCARD_NONREF)
6186 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
6187 if (vc1_decode_sprites(v, &s->gb))
6190 if ((ret = av_frame_ref(pict, &v->sprite_output_frame)) < 0)
6194 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
6195 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
6197 ff_print_debug_info(s, s->current_picture_ptr, pict);
6198 } else if (s->last_picture_ptr != NULL) {
6199 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
6201 ff_print_debug_info(s, s->last_picture_ptr, pict);
6203 if (s->last_picture_ptr || s->low_delay) {
6210 for (i = 0; i < n_slices; i++)
6211 av_free(slices[i].buf);
6217 for (i = 0; i < n_slices; i++)
6218 av_free(slices[i].buf);
6224 static const AVProfile profiles[] = {
6225 { FF_PROFILE_VC1_SIMPLE, "Simple" },
6226 { FF_PROFILE_VC1_MAIN, "Main" },
6227 { FF_PROFILE_VC1_COMPLEX, "Complex" },
6228 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
6229 { FF_PROFILE_UNKNOWN },
6232 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
6234 AV_PIX_FMT_DXVA2_VLD,
6237 AV_PIX_FMT_VAAPI_VLD,
6246 AVCodec ff_vc1_decoder = {
6248 .type = AVMEDIA_TYPE_VIDEO,
6249 .id = AV_CODEC_ID_VC1,
6250 .priv_data_size = sizeof(VC1Context),
6251 .init = vc1_decode_init,
6252 .close = ff_vc1_decode_end,
6253 .decode = vc1_decode_frame,
6254 .flush = ff_mpeg_flush,
6255 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6256 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
6257 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6258 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6261 #if CONFIG_WMV3_DECODER
6262 AVCodec ff_wmv3_decoder = {
6264 .type = AVMEDIA_TYPE_VIDEO,
6265 .id = AV_CODEC_ID_WMV3,
6266 .priv_data_size = sizeof(VC1Context),
6267 .init = vc1_decode_init,
6268 .close = ff_vc1_decode_end,
6269 .decode = vc1_decode_frame,
6270 .flush = ff_mpeg_flush,
6271 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6272 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
6273 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6274 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6278 #if CONFIG_WMV3_VDPAU_DECODER
6279 AVCodec ff_wmv3_vdpau_decoder = {
6280 .name = "wmv3_vdpau",
6281 .type = AVMEDIA_TYPE_VIDEO,
6282 .id = AV_CODEC_ID_WMV3,
6283 .priv_data_size = sizeof(VC1Context),
6284 .init = vc1_decode_init,
6285 .close = ff_vc1_decode_end,
6286 .decode = vc1_decode_frame,
6287 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6288 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
6289 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
6290 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6294 #if CONFIG_VC1_VDPAU_DECODER
6295 AVCodec ff_vc1_vdpau_decoder = {
6296 .name = "vc1_vdpau",
6297 .type = AVMEDIA_TYPE_VIDEO,
6298 .id = AV_CODEC_ID_VC1,
6299 .priv_data_size = sizeof(VC1Context),
6300 .init = vc1_decode_init,
6301 .close = ff_vc1_decode_end,
6302 .decode = vc1_decode_frame,
6303 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6304 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
6305 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
6306 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6310 #if CONFIG_WMV3IMAGE_DECODER
6311 AVCodec ff_wmv3image_decoder = {
6312 .name = "wmv3image",
6313 .type = AVMEDIA_TYPE_VIDEO,
6314 .id = AV_CODEC_ID_WMV3IMAGE,
6315 .priv_data_size = sizeof(VC1Context),
6316 .init = vc1_decode_init,
6317 .close = ff_vc1_decode_end,
6318 .decode = vc1_decode_frame,
6319 .capabilities = CODEC_CAP_DR1,
6320 .flush = vc1_sprite_flush,
6321 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
6322 .pix_fmts = ff_pixfmt_list_420
6326 #if CONFIG_VC1IMAGE_DECODER
6327 AVCodec ff_vc1image_decoder = {
6329 .type = AVMEDIA_TYPE_VIDEO,
6330 .id = AV_CODEC_ID_VC1IMAGE,
6331 .priv_data_size = sizeof(VC1Context),
6332 .init = vc1_decode_init,
6333 .close = ff_vc1_decode_end,
6334 .decode = vc1_decode_frame,
6335 .capabilities = CODEC_CAP_DR1,
6336 .flush = vc1_sprite_flush,
6337 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
6338 .pix_fmts = ff_pixfmt_list_420