2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of Libav.
9 * Libav is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * Libav is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with Libav; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
31 #include "error_resilience.h"
32 #include "mpegvideo.h"
34 #include "h264chroma.h"
37 #include "vc1acdata.h"
38 #include "msmpeg4data.h"
45 #define MB_INTRA_VLC_BITS 9
49 // offset tables for interlaced picture MVDATA decoding
50 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
51 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
53 /***********************************************************************/
55 * @name VC-1 Bitplane decoding
73 /** @} */ //imode defines
75 static void init_block_index(VC1Context *v)
77 MpegEncContext *s = &v->s;
78 ff_init_block_index(s);
79 if (v->field_mode && !(v->second_field ^ v->tff)) {
80 s->dest[0] += s->current_picture_ptr->f.linesize[0];
81 s->dest[1] += s->current_picture_ptr->f.linesize[1];
82 s->dest[2] += s->current_picture_ptr->f.linesize[2];
86 /** @} */ //Bitplane group
88 static void vc1_put_signed_blocks_clamped(VC1Context *v)
90 MpegEncContext *s = &v->s;
91 int topleft_mb_pos, top_mb_pos;
92 int stride_y, fieldtx = 0;
95 /* The put pixels loop is always one MB row behind the decoding loop,
96 * because we can only put pixels when overlap filtering is done, and
97 * for filtering of the bottom edge of a MB, we need the next MB row
99 * Within the row, the put pixels loop is also one MB col behind the
100 * decoding loop. The reason for this is again, because for filtering
101 * of the right MB edge, we need the next MB present. */
102 if (!s->first_slice_line) {
104 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
105 if (v->fcm == ILACE_FRAME)
106 fieldtx = v->fieldtx_plane[topleft_mb_pos];
107 stride_y = s->linesize << fieldtx;
108 v_dist = (16 - fieldtx) >> (fieldtx == 0);
109 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
110 s->dest[0] - 16 * s->linesize - 16,
112 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
113 s->dest[0] - 16 * s->linesize - 8,
115 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
116 s->dest[0] - v_dist * s->linesize - 16,
118 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
119 s->dest[0] - v_dist * s->linesize - 8,
121 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
122 s->dest[1] - 8 * s->uvlinesize - 8,
124 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
125 s->dest[2] - 8 * s->uvlinesize - 8,
128 if (s->mb_x == s->mb_width - 1) {
129 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
130 if (v->fcm == ILACE_FRAME)
131 fieldtx = v->fieldtx_plane[top_mb_pos];
132 stride_y = s->linesize << fieldtx;
133 v_dist = fieldtx ? 15 : 8;
134 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
135 s->dest[0] - 16 * s->linesize,
137 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
138 s->dest[0] - 16 * s->linesize + 8,
140 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
141 s->dest[0] - v_dist * s->linesize,
143 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
144 s->dest[0] - v_dist * s->linesize + 8,
146 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
147 s->dest[1] - 8 * s->uvlinesize,
149 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
150 s->dest[2] - 8 * s->uvlinesize,
155 #define inc_blk_idx(idx) do { \
157 if (idx >= v->n_allocated_blks) \
161 inc_blk_idx(v->topleft_blk_idx);
162 inc_blk_idx(v->top_blk_idx);
163 inc_blk_idx(v->left_blk_idx);
164 inc_blk_idx(v->cur_blk_idx);
167 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
169 MpegEncContext *s = &v->s;
171 if (!s->first_slice_line) {
172 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
174 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
175 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
176 for (j = 0; j < 2; j++) {
177 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
179 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
182 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
184 if (s->mb_y == s->end_mb_y - 1) {
186 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
187 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
188 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
190 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
194 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
196 MpegEncContext *s = &v->s;
199 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
200 * means it runs two rows/cols behind the decoding loop. */
201 if (!s->first_slice_line) {
203 if (s->mb_y >= s->start_mb_y + 2) {
204 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
207 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
208 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
209 for (j = 0; j < 2; j++) {
210 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
212 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
216 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
219 if (s->mb_x == s->mb_width - 1) {
220 if (s->mb_y >= s->start_mb_y + 2) {
221 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
224 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
225 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
226 for (j = 0; j < 2; j++) {
227 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
229 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
233 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
236 if (s->mb_y == s->end_mb_y) {
239 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
240 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
242 for (j = 0; j < 2; j++) {
243 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
248 if (s->mb_x == s->mb_width - 1) {
250 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
251 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
253 for (j = 0; j < 2; j++) {
254 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
262 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
264 MpegEncContext *s = &v->s;
267 if (v->condover == CONDOVER_NONE)
270 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
272 /* Within a MB, the horizontal overlap always runs before the vertical.
273 * To accomplish that, we run the H on left and internal borders of the
274 * currently decoded MB. Then, we wait for the next overlap iteration
275 * to do H overlap on the right edge of this MB, before moving over and
276 * running the V overlap. Therefore, the V overlap makes us trail by one
277 * MB col and the H overlap filter makes us trail by one MB row. This
278 * is reflected in the time at which we run the put_pixels loop. */
279 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
280 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
281 v->over_flags_plane[mb_pos - 1])) {
282 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
283 v->block[v->cur_blk_idx][0]);
284 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
285 v->block[v->cur_blk_idx][2]);
286 if (!(s->flags & CODEC_FLAG_GRAY)) {
287 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
288 v->block[v->cur_blk_idx][4]);
289 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
290 v->block[v->cur_blk_idx][5]);
293 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
294 v->block[v->cur_blk_idx][1]);
295 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
296 v->block[v->cur_blk_idx][3]);
298 if (s->mb_x == s->mb_width - 1) {
299 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
300 v->over_flags_plane[mb_pos - s->mb_stride])) {
301 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
302 v->block[v->cur_blk_idx][0]);
303 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
304 v->block[v->cur_blk_idx][1]);
305 if (!(s->flags & CODEC_FLAG_GRAY)) {
306 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
307 v->block[v->cur_blk_idx][4]);
308 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
309 v->block[v->cur_blk_idx][5]);
312 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
313 v->block[v->cur_blk_idx][2]);
314 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
315 v->block[v->cur_blk_idx][3]);
318 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
319 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
320 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
321 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
322 v->block[v->left_blk_idx][0]);
323 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
324 v->block[v->left_blk_idx][1]);
325 if (!(s->flags & CODEC_FLAG_GRAY)) {
326 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
327 v->block[v->left_blk_idx][4]);
328 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
329 v->block[v->left_blk_idx][5]);
332 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
333 v->block[v->left_blk_idx][2]);
334 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
335 v->block[v->left_blk_idx][3]);
339 /** Do motion compensation over 1 macroblock
340 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
342 static void vc1_mc_1mv(VC1Context *v, int dir)
344 MpegEncContext *s = &v->s;
345 H264ChromaContext *h264chroma = &v->h264chroma;
346 uint8_t *srcY, *srcU, *srcV;
347 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
348 int v_edge_pos = s->v_edge_pos >> v->field_mode;
350 uint8_t (*luty)[256], (*lutuv)[256];
353 if ((!v->field_mode ||
354 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
355 !v->s.last_picture.f.data[0])
358 mx = s->mv[dir][0][0];
359 my = s->mv[dir][0][1];
361 // store motion vectors for further use in B frames
362 if (s->pict_type == AV_PICTURE_TYPE_P) {
363 for (i = 0; i < 4; i++) {
364 s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = mx;
365 s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = my;
369 uvmx = (mx + ((mx & 3) == 3)) >> 1;
370 uvmy = (my + ((my & 3) == 3)) >> 1;
371 v->luma_mv[s->mb_x][0] = uvmx;
372 v->luma_mv[s->mb_x][1] = uvmy;
375 v->cur_field_type != v->ref_field_type[dir]) {
376 my = my - 2 + 4 * v->cur_field_type;
377 uvmy = uvmy - 2 + 4 * v->cur_field_type;
380 // fastuvmc shall be ignored for interlaced frame picture
381 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
382 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
383 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
386 if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
387 srcY = s->current_picture.f.data[0];
388 srcU = s->current_picture.f.data[1];
389 srcV = s->current_picture.f.data[2];
391 lutuv = v->curr_lutuv;
392 use_ic = v->curr_use_ic;
394 srcY = s->last_picture.f.data[0];
395 srcU = s->last_picture.f.data[1];
396 srcV = s->last_picture.f.data[2];
398 lutuv = v->last_lutuv;
399 use_ic = v->last_use_ic;
402 srcY = s->next_picture.f.data[0];
403 srcU = s->next_picture.f.data[1];
404 srcV = s->next_picture.f.data[2];
406 lutuv = v->next_lutuv;
407 use_ic = v->next_use_ic;
410 if (!srcY || !srcU) {
411 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
415 src_x = s->mb_x * 16 + (mx >> 2);
416 src_y = s->mb_y * 16 + (my >> 2);
417 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
418 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
420 if (v->profile != PROFILE_ADVANCED) {
421 src_x = av_clip( src_x, -16, s->mb_width * 16);
422 src_y = av_clip( src_y, -16, s->mb_height * 16);
423 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
424 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
426 src_x = av_clip( src_x, -17, s->avctx->coded_width);
427 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
428 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
429 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
432 srcY += src_y * s->linesize + src_x;
433 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
434 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
436 if (v->field_mode && v->ref_field_type[dir]) {
437 srcY += s->current_picture_ptr->f.linesize[0];
438 srcU += s->current_picture_ptr->f.linesize[1];
439 srcV += s->current_picture_ptr->f.linesize[2];
442 /* for grayscale we should not try to read from unknown area */
443 if (s->flags & CODEC_FLAG_GRAY) {
444 srcU = s->edge_emu_buffer + 18 * s->linesize;
445 srcV = s->edge_emu_buffer + 18 * s->linesize;
448 if (v->rangeredfrm || use_ic
449 || s->h_edge_pos < 22 || v_edge_pos < 22
450 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
451 || (unsigned)(src_y - 1) > v_edge_pos - (my&3) - 16 - 3) {
452 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
454 srcY -= s->mspel * (1 + s->linesize);
455 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
456 17 + s->mspel * 2, 17 + s->mspel * 2,
457 src_x - s->mspel, src_y - s->mspel,
458 s->h_edge_pos, v_edge_pos);
459 srcY = s->edge_emu_buffer;
460 s->vdsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
461 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
462 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
463 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
466 /* if we deal with range reduction we need to scale source blocks */
467 if (v->rangeredfrm) {
472 for (j = 0; j < 17 + s->mspel * 2; j++) {
473 for (i = 0; i < 17 + s->mspel * 2; i++)
474 src[i] = ((src[i] - 128) >> 1) + 128;
479 for (j = 0; j < 9; j++) {
480 for (i = 0; i < 9; i++) {
481 src[i] = ((src[i] - 128) >> 1) + 128;
482 src2[i] = ((src2[i] - 128) >> 1) + 128;
484 src += s->uvlinesize;
485 src2 += s->uvlinesize;
488 /* if we deal with intensity compensation we need to scale source blocks */
494 for (j = 0; j < 17 + s->mspel * 2; j++) {
495 int f = v->field_mode ? v->ref_field_type[dir] : ((j + src_y - s->mspel) & 1) ;
496 for (i = 0; i < 17 + s->mspel * 2; i++)
497 src[i] = luty[f][src[i]];
502 for (j = 0; j < 9; j++) {
503 int f = v->field_mode ? v->ref_field_type[dir] : ((j + uvsrc_y) & 1);
504 for (i = 0; i < 9; i++) {
505 src[i] = lutuv[f][src[i]];
506 src2[i] = lutuv[f][src2[i]];
508 src += s->uvlinesize;
509 src2 += s->uvlinesize;
512 srcY += s->mspel * (1 + s->linesize);
516 dxy = ((my & 3) << 2) | (mx & 3);
517 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
518 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
519 srcY += s->linesize * 8;
520 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
521 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
522 } else { // hpel mc - always used for luma
523 dxy = (my & 2) | ((mx & 2) >> 1);
525 s->hdsp.put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
527 s->hdsp.put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
530 if (s->flags & CODEC_FLAG_GRAY) return;
531 /* Chroma MC always uses qpel bilinear */
532 uvmx = (uvmx & 3) << 1;
533 uvmy = (uvmy & 3) << 1;
535 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
536 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
538 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
539 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
543 static inline int median4(int a, int b, int c, int d)
546 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
547 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
549 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
550 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
554 /** Do motion compensation for 4-MV macroblock - luminance block
556 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
558 MpegEncContext *s = &v->s;
560 int dxy, mx, my, src_x, src_y;
562 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
563 int v_edge_pos = s->v_edge_pos >> v->field_mode;
564 uint8_t (*luty)[256];
567 if ((!v->field_mode ||
568 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
569 !v->s.last_picture.f.data[0])
572 mx = s->mv[dir][n][0];
573 my = s->mv[dir][n][1];
576 if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
577 srcY = s->current_picture.f.data[0];
579 use_ic = v->curr_use_ic;
581 srcY = s->last_picture.f.data[0];
583 use_ic = v->last_use_ic;
586 srcY = s->next_picture.f.data[0];
588 use_ic = v->next_use_ic;
592 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
597 if (v->cur_field_type != v->ref_field_type[dir])
598 my = my - 2 + 4 * v->cur_field_type;
601 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
602 int same_count = 0, opp_count = 0, k;
603 int chosen_mv[2][4][2], f;
605 for (k = 0; k < 4; k++) {
606 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
607 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
608 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
612 f = opp_count > same_count;
613 switch (f ? opp_count : same_count) {
615 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
616 chosen_mv[f][2][0], chosen_mv[f][3][0]);
617 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
618 chosen_mv[f][2][1], chosen_mv[f][3][1]);
621 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
622 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
625 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
626 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
629 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
630 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
631 for (k = 0; k < 4; k++)
632 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
635 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
637 int width = s->avctx->coded_width;
638 int height = s->avctx->coded_height >> 1;
639 if (s->pict_type == AV_PICTURE_TYPE_P) {
640 s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][0] = mx;
641 s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][1] = my;
643 qx = (s->mb_x * 16) + (mx >> 2);
644 qy = (s->mb_y * 8) + (my >> 3);
649 mx -= 4 * (qx - width);
652 else if (qy > height + 1)
653 my -= 8 * (qy - height - 1);
656 if ((v->fcm == ILACE_FRAME) && fieldmv)
657 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
659 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
661 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
663 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
665 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
667 if (v->profile != PROFILE_ADVANCED) {
668 src_x = av_clip(src_x, -16, s->mb_width * 16);
669 src_y = av_clip(src_y, -16, s->mb_height * 16);
671 src_x = av_clip(src_x, -17, s->avctx->coded_width);
672 if (v->fcm == ILACE_FRAME) {
674 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
676 src_y = av_clip(src_y, -18, s->avctx->coded_height);
678 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
682 srcY += src_y * s->linesize + src_x;
683 if (v->field_mode && v->ref_field_type[dir])
684 srcY += s->current_picture_ptr->f.linesize[0];
686 if (fieldmv && !(src_y & 1))
688 if (fieldmv && (src_y & 1) && src_y < 4)
690 if (v->rangeredfrm || use_ic
691 || s->h_edge_pos < 13 || v_edge_pos < 23
692 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
693 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
694 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
695 /* check emulate edge stride and offset */
696 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
697 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
698 src_x - s->mspel, src_y - (s->mspel << fieldmv),
699 s->h_edge_pos, v_edge_pos);
700 srcY = s->edge_emu_buffer;
701 /* if we deal with range reduction we need to scale source blocks */
702 if (v->rangeredfrm) {
707 for (j = 0; j < 9 + s->mspel * 2; j++) {
708 for (i = 0; i < 9 + s->mspel * 2; i++)
709 src[i] = ((src[i] - 128) >> 1) + 128;
710 src += s->linesize << fieldmv;
713 /* if we deal with intensity compensation we need to scale source blocks */
719 for (j = 0; j < 9 + s->mspel * 2; j++) {
720 int f = v->field_mode ? v->ref_field_type[dir] : (((j<<fieldmv)+src_y - (s->mspel << fieldmv)) & 1);
721 for (i = 0; i < 9 + s->mspel * 2; i++)
722 src[i] = luty[f][src[i]];
723 src += s->linesize << fieldmv;
726 srcY += s->mspel * (1 + (s->linesize << fieldmv));
730 dxy = ((my & 3) << 2) | (mx & 3);
732 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
734 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
735 } else { // hpel mc - always used for luma
736 dxy = (my & 2) | ((mx & 2) >> 1);
738 s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
740 s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
744 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
747 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
749 idx = ((a[3] != flag) << 3)
750 | ((a[2] != flag) << 2)
751 | ((a[1] != flag) << 1)
754 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
755 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
757 } else if (count[idx] == 1) {
760 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
761 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
764 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
765 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
768 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
769 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
772 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
773 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
776 } else if (count[idx] == 2) {
778 for (i = 0; i < 3; i++)
783 for (i = t1 + 1; i < 4; i++)
788 *tx = (mvx[t1] + mvx[t2]) / 2;
789 *ty = (mvy[t1] + mvy[t2]) / 2;
797 /** Do motion compensation for 4-MV macroblock - both chroma blocks
799 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
801 MpegEncContext *s = &v->s;
802 H264ChromaContext *h264chroma = &v->h264chroma;
803 uint8_t *srcU, *srcV;
804 int uvmx, uvmy, uvsrc_x, uvsrc_y;
805 int k, tx = 0, ty = 0;
806 int mvx[4], mvy[4], intra[4], mv_f[4];
808 int chroma_ref_type = v->cur_field_type;
809 int v_edge_pos = s->v_edge_pos >> v->field_mode;
810 uint8_t (*lutuv)[256];
813 if (!v->field_mode && !v->s.last_picture.f.data[0])
815 if (s->flags & CODEC_FLAG_GRAY)
818 for (k = 0; k < 4; k++) {
819 mvx[k] = s->mv[dir][k][0];
820 mvy[k] = s->mv[dir][k][1];
821 intra[k] = v->mb_type[0][s->block_index[k]];
823 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
826 /* calculate chroma MV vector from four luma MVs */
827 if (!v->field_mode || (v->field_mode && !v->numref)) {
828 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
829 chroma_ref_type = v->reffield;
831 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
832 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
833 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
834 return; //no need to do MC for intra blocks
838 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
840 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
842 chroma_ref_type = !v->cur_field_type;
844 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
846 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
847 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
848 uvmx = (tx + ((tx & 3) == 3)) >> 1;
849 uvmy = (ty + ((ty & 3) == 3)) >> 1;
851 v->luma_mv[s->mb_x][0] = uvmx;
852 v->luma_mv[s->mb_x][1] = uvmy;
855 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
856 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
858 // Field conversion bias
859 if (v->cur_field_type != chroma_ref_type)
860 uvmy += 2 - 4 * chroma_ref_type;
862 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
863 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
865 if (v->profile != PROFILE_ADVANCED) {
866 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
867 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
869 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
870 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
874 if (v->field_mode && (v->cur_field_type != chroma_ref_type) && v->second_field) {
875 srcU = s->current_picture.f.data[1];
876 srcV = s->current_picture.f.data[2];
877 lutuv = v->curr_lutuv;
878 use_ic = v->curr_use_ic;
880 srcU = s->last_picture.f.data[1];
881 srcV = s->last_picture.f.data[2];
882 lutuv = v->last_lutuv;
883 use_ic = v->last_use_ic;
886 srcU = s->next_picture.f.data[1];
887 srcV = s->next_picture.f.data[2];
888 lutuv = v->next_lutuv;
889 use_ic = v->next_use_ic;
893 av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
897 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
898 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
901 if (chroma_ref_type) {
902 srcU += s->current_picture_ptr->f.linesize[1];
903 srcV += s->current_picture_ptr->f.linesize[2];
907 if (v->rangeredfrm || use_ic
908 || s->h_edge_pos < 18 || v_edge_pos < 18
909 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
910 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
911 s->vdsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
912 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
913 s->h_edge_pos >> 1, v_edge_pos >> 1);
914 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
915 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
916 s->h_edge_pos >> 1, v_edge_pos >> 1);
917 srcU = s->edge_emu_buffer;
918 srcV = s->edge_emu_buffer + 16;
920 /* if we deal with range reduction we need to scale source blocks */
921 if (v->rangeredfrm) {
927 for (j = 0; j < 9; j++) {
928 for (i = 0; i < 9; i++) {
929 src[i] = ((src[i] - 128) >> 1) + 128;
930 src2[i] = ((src2[i] - 128) >> 1) + 128;
932 src += s->uvlinesize;
933 src2 += s->uvlinesize;
936 /* if we deal with intensity compensation we need to scale source blocks */
943 for (j = 0; j < 9; j++) {
944 int f = v->field_mode ? chroma_ref_type : ((j + uvsrc_y) & 1);
945 for (i = 0; i < 9; i++) {
946 src[i] = lutuv[f][src[i]];
947 src2[i] = lutuv[f][src2[i]];
949 src += s->uvlinesize;
950 src2 += s->uvlinesize;
955 /* Chroma MC always uses qpel bilinear */
956 uvmx = (uvmx & 3) << 1;
957 uvmy = (uvmy & 3) << 1;
959 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
960 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
962 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
963 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
967 /** Do motion compensation for 4-MV interlaced frame chroma macroblock (both U and V)
969 static void vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)
971 MpegEncContext *s = &v->s;
972 H264ChromaContext *h264chroma = &v->h264chroma;
973 uint8_t *srcU, *srcV;
974 int uvsrc_x, uvsrc_y;
975 int uvmx_field[4], uvmy_field[4];
977 int fieldmv = v->blk_mv_type[s->block_index[0]];
978 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
979 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
980 int v_edge_pos = s->v_edge_pos >> 1;
982 uint8_t (*lutuv)[256];
984 if (s->flags & CODEC_FLAG_GRAY)
987 for (i = 0; i < 4; i++) {
988 int d = i < 2 ? dir: dir2;
990 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
993 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
995 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
998 for (i = 0; i < 4; i++) {
999 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
1000 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
1001 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
1002 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
1003 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1004 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1005 if (i < 2 ? dir : dir2) {
1006 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1007 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1008 lutuv = v->next_lutuv;
1009 use_ic = v->next_use_ic;
1011 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1012 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1013 lutuv = v->last_lutuv;
1014 use_ic = v->last_use_ic;
1016 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
1017 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
1019 if (fieldmv && !(uvsrc_y & 1))
1021 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
1024 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
1025 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
1026 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
1027 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
1028 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1029 s->h_edge_pos >> 1, v_edge_pos);
1030 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
1031 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1032 s->h_edge_pos >> 1, v_edge_pos);
1033 srcU = s->edge_emu_buffer;
1034 srcV = s->edge_emu_buffer + 16;
1036 /* if we deal with intensity compensation we need to scale source blocks */
1039 uint8_t *src, *src2;
1043 for (j = 0; j < 5; j++) {
1044 int f = (uvsrc_y + (j << fieldmv)) & 1;
1045 for (i = 0; i < 5; i++) {
1046 src[i] = lutuv[f][src[i]];
1047 src2[i] = lutuv[f][src2[i]];
1049 src += s->uvlinesize << fieldmv;
1050 src2 += s->uvlinesize << fieldmv;
1056 h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1057 h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1059 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]);
1060 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]);
1064 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1065 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1067 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]);
1068 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]);
1074 /***********************************************************************/
1076 * @name VC-1 Block-level functions
1077 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1083 * @brief Get macroblock-level quantizer scale
1085 #define GET_MQUANT() \
1086 if (v->dquantfrm) { \
1088 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1089 if (v->dqbilevel) { \
1090 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1092 mqdiff = get_bits(gb, 3); \
1094 mquant = v->pq + mqdiff; \
1096 mquant = get_bits(gb, 5); \
1099 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1100 edges = 1 << v->dqsbedge; \
1101 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1102 edges = (3 << v->dqsbedge) % 15; \
1103 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1105 if ((edges&1) && !s->mb_x) \
1106 mquant = v->altpq; \
1107 if ((edges&2) && s->first_slice_line) \
1108 mquant = v->altpq; \
1109 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1110 mquant = v->altpq; \
1111 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1112 mquant = v->altpq; \
1113 if (!mquant || mquant > 31) { \
1114 av_log(v->s.avctx, AV_LOG_ERROR, \
1115 "Overriding invalid mquant %d\n", mquant); \
1121 * @def GET_MVDATA(_dmv_x, _dmv_y)
1122 * @brief Get MV differentials
1123 * @see MVDATA decoding from 8.3.5.2, p(1)20
1124 * @param _dmv_x Horizontal differential for decoded MV
1125 * @param _dmv_y Vertical differential for decoded MV
1127 #define GET_MVDATA(_dmv_x, _dmv_y) \
1128 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1129 VC1_MV_DIFF_VLC_BITS, 2); \
1131 mb_has_coeffs = 1; \
1134 mb_has_coeffs = 0; \
1137 _dmv_x = _dmv_y = 0; \
1138 } else if (index == 35) { \
1139 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1140 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1141 } else if (index == 36) { \
1146 index1 = index % 6; \
1147 if (!s->quarter_sample && index1 == 5) val = 1; \
1149 if (size_table[index1] - val > 0) \
1150 val = get_bits(gb, size_table[index1] - val); \
1152 sign = 0 - (val&1); \
1153 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1155 index1 = index / 6; \
1156 if (!s->quarter_sample && index1 == 5) val = 1; \
1158 if (size_table[index1] - val > 0) \
1159 val = get_bits(gb, size_table[index1] - val); \
1161 sign = 0 - (val & 1); \
1162 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1165 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1166 int *dmv_y, int *pred_flag)
1169 int extend_x = 0, extend_y = 0;
1170 GetBitContext *gb = &v->s.gb;
1173 const int* offs_tab;
1176 bits = VC1_2REF_MVDATA_VLC_BITS;
1179 bits = VC1_1REF_MVDATA_VLC_BITS;
1182 switch (v->dmvrange) {
1190 extend_x = extend_y = 1;
1193 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1195 *dmv_x = get_bits(gb, v->k_x);
1196 *dmv_y = get_bits(gb, v->k_y);
1199 *pred_flag = *dmv_y & 1;
1200 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1202 *dmv_y = (*dmv_y + (*dmv_y & 1)) >> 1;
1208 offs_tab = offset_table2;
1210 offs_tab = offset_table1;
1211 index1 = (index + 1) % 9;
1213 val = get_bits(gb, index1 + extend_x);
1214 sign = 0 -(val & 1);
1215 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1219 offs_tab = offset_table2;
1221 offs_tab = offset_table1;
1222 index1 = (index + 1) / 9;
1223 if (index1 > v->numref) {
1224 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1225 sign = 0 - (val & 1);
1226 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1229 if (v->numref && pred_flag)
1230 *pred_flag = index1 & 1;
1234 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1236 int scaledvalue, refdist;
1237 int scalesame1, scalesame2;
1238 int scalezone1_x, zone1offset_x;
1239 int table_index = dir ^ v->second_field;
1241 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1242 refdist = v->refdist;
1244 refdist = dir ? v->brfd : v->frfd;
1247 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1248 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1249 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1250 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1255 if (FFABS(n) < scalezone1_x)
1256 scaledvalue = (n * scalesame1) >> 8;
1259 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1261 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1264 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1267 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1269 int scaledvalue, refdist;
1270 int scalesame1, scalesame2;
1271 int scalezone1_y, zone1offset_y;
1272 int table_index = dir ^ v->second_field;
1274 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1275 refdist = v->refdist;
1277 refdist = dir ? v->brfd : v->frfd;
1280 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1281 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1282 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1283 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1288 if (FFABS(n) < scalezone1_y)
1289 scaledvalue = (n * scalesame1) >> 8;
1292 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1294 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1298 if (v->cur_field_type && !v->ref_field_type[dir])
1299 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1301 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1304 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1306 int scalezone1_x, zone1offset_x;
1307 int scaleopp1, scaleopp2, brfd;
1310 brfd = FFMIN(v->brfd, 3);
1311 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1312 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1313 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1314 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1319 if (FFABS(n) < scalezone1_x)
1320 scaledvalue = (n * scaleopp1) >> 8;
1323 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1325 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1328 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1331 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1333 int scalezone1_y, zone1offset_y;
1334 int scaleopp1, scaleopp2, brfd;
1337 brfd = FFMIN(v->brfd, 3);
1338 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1339 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1340 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1341 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1346 if (FFABS(n) < scalezone1_y)
1347 scaledvalue = (n * scaleopp1) >> 8;
1350 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1352 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1355 if (v->cur_field_type && !v->ref_field_type[dir]) {
1356 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1358 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1362 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1365 int brfd, scalesame;
1366 int hpel = 1 - v->s.quarter_sample;
1369 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1371 n = scaleforsame_y(v, i, n, dir) << hpel;
1373 n = scaleforsame_x(v, n, dir) << hpel;
1376 brfd = FFMIN(v->brfd, 3);
1377 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1379 n = (n * scalesame >> 8) << hpel;
1383 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1386 int refdist, scaleopp;
1387 int hpel = 1 - v->s.quarter_sample;
1390 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1392 n = scaleforopp_y(v, n, dir) << hpel;
1394 n = scaleforopp_x(v, n) << hpel;
1397 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1398 refdist = FFMIN(v->refdist, 3);
1400 refdist = dir ? v->brfd : v->frfd;
1401 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1403 n = (n * scaleopp >> 8) << hpel;
1407 /** Predict and set motion vector
1409 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1410 int mv1, int r_x, int r_y, uint8_t* is_intra,
1411 int pred_flag, int dir)
1413 MpegEncContext *s = &v->s;
1414 int xy, wrap, off = 0;
1418 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1419 int opposite, a_f, b_f, c_f;
1420 int16_t field_predA[2];
1421 int16_t field_predB[2];
1422 int16_t field_predC[2];
1423 int a_valid, b_valid, c_valid;
1424 int hybridmv_thresh, y_bias = 0;
1426 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1427 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1431 /* scale MV difference to be quad-pel */
1432 dmv_x <<= 1 - s->quarter_sample;
1433 dmv_y <<= 1 - s->quarter_sample;
1435 wrap = s->b8_stride;
1436 xy = s->block_index[n];
1439 s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
1440 s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
1441 s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
1442 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
1443 if (mv1) { /* duplicate motion data for 1-MV block */
1444 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1445 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1446 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1447 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1448 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1449 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1450 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1451 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1452 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1453 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1454 s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1455 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1456 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1461 C = s->current_picture.motion_val[dir][xy - 1 + v->blocks_off];
1462 A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
1464 if (v->field_mode && mixedmv_pic)
1465 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1467 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1469 //in 4-MV mode different blocks have different B predictor position
1472 off = (s->mb_x > 0) ? -1 : 1;
1475 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1484 B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
1486 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1487 b_valid = a_valid && (s->mb_width > 1);
1488 c_valid = s->mb_x || (n == 1 || n == 3);
1489 if (v->field_mode) {
1490 a_valid = a_valid && !is_intra[xy - wrap];
1491 b_valid = b_valid && !is_intra[xy - wrap + off];
1492 c_valid = c_valid && !is_intra[xy - 1];
1496 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1497 num_oppfield += a_f;
1498 num_samefield += 1 - a_f;
1499 field_predA[0] = A[0];
1500 field_predA[1] = A[1];
1502 field_predA[0] = field_predA[1] = 0;
1506 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1507 num_oppfield += b_f;
1508 num_samefield += 1 - b_f;
1509 field_predB[0] = B[0];
1510 field_predB[1] = B[1];
1512 field_predB[0] = field_predB[1] = 0;
1516 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1517 num_oppfield += c_f;
1518 num_samefield += 1 - c_f;
1519 field_predC[0] = C[0];
1520 field_predC[1] = C[1];
1522 field_predC[0] = field_predC[1] = 0;
1526 if (v->field_mode) {
1528 // REFFIELD determines if the last field or the second-last field is
1529 // to be used as reference
1530 opposite = 1 - v->reffield;
1532 if (num_samefield <= num_oppfield)
1533 opposite = 1 - pred_flag;
1535 opposite = pred_flag;
1540 if (a_valid && !a_f) {
1541 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1542 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1544 if (b_valid && !b_f) {
1545 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1546 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1548 if (c_valid && !c_f) {
1549 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1550 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1552 v->mv_f[dir][xy + v->blocks_off] = 1;
1553 v->ref_field_type[dir] = !v->cur_field_type;
1555 if (a_valid && a_f) {
1556 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1557 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1559 if (b_valid && b_f) {
1560 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1561 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1563 if (c_valid && c_f) {
1564 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1565 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1567 v->mv_f[dir][xy + v->blocks_off] = 0;
1568 v->ref_field_type[dir] = v->cur_field_type;
1572 px = field_predA[0];
1573 py = field_predA[1];
1574 } else if (c_valid) {
1575 px = field_predC[0];
1576 py = field_predC[1];
1577 } else if (b_valid) {
1578 px = field_predB[0];
1579 py = field_predB[1];
1585 if (num_samefield + num_oppfield > 1) {
1586 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1587 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1590 /* Pullback MV as specified in 8.3.5.3.4 */
1591 if (!v->field_mode) {
1593 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1594 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1595 X = (s->mb_width << 6) - 4;
1596 Y = (s->mb_height << 6) - 4;
1598 if (qx + px < -60) px = -60 - qx;
1599 if (qy + py < -60) py = -60 - qy;
1601 if (qx + px < -28) px = -28 - qx;
1602 if (qy + py < -28) py = -28 - qy;
1604 if (qx + px > X) px = X - qx;
1605 if (qy + py > Y) py = Y - qy;
1608 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1609 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1610 hybridmv_thresh = 32;
1611 if (a_valid && c_valid) {
1612 if (is_intra[xy - wrap])
1613 sum = FFABS(px) + FFABS(py);
1615 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1616 if (sum > hybridmv_thresh) {
1617 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1618 px = field_predA[0];
1619 py = field_predA[1];
1621 px = field_predC[0];
1622 py = field_predC[1];
1625 if (is_intra[xy - 1])
1626 sum = FFABS(px) + FFABS(py);
1628 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1629 if (sum > hybridmv_thresh) {
1630 if (get_bits1(&s->gb)) {
1631 px = field_predA[0];
1632 py = field_predA[1];
1634 px = field_predC[0];
1635 py = field_predC[1];
1642 if (v->field_mode && v->numref)
1644 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1646 /* store MV using signed modulus of MV range defined in 4.11 */
1647 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;
1648 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;
1649 if (mv1) { /* duplicate motion data for 1-MV block */
1650 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1651 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1652 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1653 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1654 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1655 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1656 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1657 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];
1661 /** Predict and set motion vector for interlaced frame picture MBs
1663 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1664 int mvn, int r_x, int r_y, uint8_t* is_intra, int dir)
1666 MpegEncContext *s = &v->s;
1667 int xy, wrap, off = 0;
1668 int A[2], B[2], C[2];
1670 int a_valid = 0, b_valid = 0, c_valid = 0;
1671 int field_a, field_b, field_c; // 0: same, 1: opposit
1672 int total_valid, num_samefield, num_oppfield;
1673 int pos_c, pos_b, n_adj;
1675 wrap = s->b8_stride;
1676 xy = s->block_index[n];
1679 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1680 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1681 s->current_picture.motion_val[1][xy][0] = 0;
1682 s->current_picture.motion_val[1][xy][1] = 0;
1683 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1684 s->current_picture.motion_val[0][xy + 1][0] = 0;
1685 s->current_picture.motion_val[0][xy + 1][1] = 0;
1686 s->current_picture.motion_val[0][xy + wrap][0] = 0;
1687 s->current_picture.motion_val[0][xy + wrap][1] = 0;
1688 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1689 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1690 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1691 s->current_picture.motion_val[1][xy + 1][0] = 0;
1692 s->current_picture.motion_val[1][xy + 1][1] = 0;
1693 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1694 s->current_picture.motion_val[1][xy + wrap][1] = 0;
1695 s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
1696 s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
1701 off = ((n == 0) || (n == 1)) ? 1 : -1;
1703 if (s->mb_x || (n == 1) || (n == 3)) {
1704 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1705 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1706 A[0] = s->current_picture.motion_val[dir][xy - 1][0];
1707 A[1] = s->current_picture.motion_val[dir][xy - 1][1];
1709 } else { // current block has frame mv and cand. has field MV (so average)
1710 A[0] = (s->current_picture.motion_val[dir][xy - 1][0]
1711 + s->current_picture.motion_val[dir][xy - 1 + off * wrap][0] + 1) >> 1;
1712 A[1] = (s->current_picture.motion_val[dir][xy - 1][1]
1713 + s->current_picture.motion_val[dir][xy - 1 + off * wrap][1] + 1) >> 1;
1716 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1722 /* Predict B and C */
1723 B[0] = B[1] = C[0] = C[1] = 0;
1724 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1725 if (!s->first_slice_line) {
1726 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1729 pos_b = s->block_index[n_adj] - 2 * wrap;
1730 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1731 n_adj = (n & 2) | (n & 1);
1733 B[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][0];
1734 B[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][1];
1735 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1736 B[0] = (B[0] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1737 B[1] = (B[1] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1740 if (s->mb_width > 1) {
1741 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1744 pos_c = s->block_index[2] - 2 * wrap + 2;
1745 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1748 C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][0];
1749 C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][1];
1750 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1751 C[0] = (1 + C[0] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1752 C[1] = (1 + C[1] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1754 if (s->mb_x == s->mb_width - 1) {
1755 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1758 pos_c = s->block_index[3] - 2 * wrap - 2;
1759 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1762 C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][0];
1763 C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][1];
1764 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1765 C[0] = (1 + C[0] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1766 C[1] = (1 + C[1] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1775 pos_b = s->block_index[1];
1777 B[0] = s->current_picture.motion_val[dir][pos_b][0];
1778 B[1] = s->current_picture.motion_val[dir][pos_b][1];
1779 pos_c = s->block_index[0];
1781 C[0] = s->current_picture.motion_val[dir][pos_c][0];
1782 C[1] = s->current_picture.motion_val[dir][pos_c][1];
1785 total_valid = a_valid + b_valid + c_valid;
1786 // check if predictor A is out of bounds
1787 if (!s->mb_x && !(n == 1 || n == 3)) {
1790 // check if predictor B is out of bounds
1791 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1792 B[0] = B[1] = C[0] = C[1] = 0;
1794 if (!v->blk_mv_type[xy]) {
1795 if (s->mb_width == 1) {
1799 if (total_valid >= 2) {
1800 px = mid_pred(A[0], B[0], C[0]);
1801 py = mid_pred(A[1], B[1], C[1]);
1802 } else if (total_valid) {
1803 if (a_valid) { px = A[0]; py = A[1]; }
1804 if (b_valid) { px = B[0]; py = B[1]; }
1805 if (c_valid) { px = C[0]; py = C[1]; }
1811 field_a = (A[1] & 4) ? 1 : 0;
1815 field_b = (B[1] & 4) ? 1 : 0;
1819 field_c = (C[1] & 4) ? 1 : 0;
1823 num_oppfield = field_a + field_b + field_c;
1824 num_samefield = total_valid - num_oppfield;
1825 if (total_valid == 3) {
1826 if ((num_samefield == 3) || (num_oppfield == 3)) {
1827 px = mid_pred(A[0], B[0], C[0]);
1828 py = mid_pred(A[1], B[1], C[1]);
1829 } else if (num_samefield >= num_oppfield) {
1830 /* take one MV from same field set depending on priority
1831 the check for B may not be necessary */
1832 px = !field_a ? A[0] : B[0];
1833 py = !field_a ? A[1] : B[1];
1835 px = field_a ? A[0] : B[0];
1836 py = field_a ? A[1] : B[1];
1838 } else if (total_valid == 2) {
1839 if (num_samefield >= num_oppfield) {
1840 if (!field_a && a_valid) {
1843 } else if (!field_b && b_valid) {
1846 } else if (c_valid) {
1851 if (field_a && a_valid) {
1854 } else if (field_b && b_valid) {
1857 } else if (c_valid) {
1862 } else if (total_valid == 1) {
1863 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1864 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1869 /* store MV using signed modulus of MV range defined in 4.11 */
1870 s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1871 s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1872 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1873 s->current_picture.motion_val[dir][xy + 1 ][0] = s->current_picture.motion_val[dir][xy][0];
1874 s->current_picture.motion_val[dir][xy + 1 ][1] = s->current_picture.motion_val[dir][xy][1];
1875 s->current_picture.motion_val[dir][xy + wrap ][0] = s->current_picture.motion_val[dir][xy][0];
1876 s->current_picture.motion_val[dir][xy + wrap ][1] = s->current_picture.motion_val[dir][xy][1];
1877 s->current_picture.motion_val[dir][xy + wrap + 1][0] = s->current_picture.motion_val[dir][xy][0];
1878 s->current_picture.motion_val[dir][xy + wrap + 1][1] = s->current_picture.motion_val[dir][xy][1];
1879 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1880 s->current_picture.motion_val[dir][xy + 1][0] = s->current_picture.motion_val[dir][xy][0];
1881 s->current_picture.motion_val[dir][xy + 1][1] = s->current_picture.motion_val[dir][xy][1];
1882 s->mv[dir][n + 1][0] = s->mv[dir][n][0];
1883 s->mv[dir][n + 1][1] = s->mv[dir][n][1];
1887 /** Motion compensation for direct or interpolated blocks in B-frames
1889 static void vc1_interp_mc(VC1Context *v)
1891 MpegEncContext *s = &v->s;
1892 H264ChromaContext *h264chroma = &v->h264chroma;
1893 uint8_t *srcY, *srcU, *srcV;
1894 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1896 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1897 int use_ic = v->next_use_ic;
1899 if (!v->field_mode && !v->s.next_picture.f.data[0])
1902 mx = s->mv[1][0][0];
1903 my = s->mv[1][0][1];
1904 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1905 uvmy = (my + ((my & 3) == 3)) >> 1;
1906 if (v->field_mode) {
1907 if (v->cur_field_type != v->ref_field_type[1])
1908 my = my - 2 + 4 * v->cur_field_type;
1909 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1912 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1913 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1915 srcY = s->next_picture.f.data[0];
1916 srcU = s->next_picture.f.data[1];
1917 srcV = s->next_picture.f.data[2];
1919 src_x = s->mb_x * 16 + (mx >> 2);
1920 src_y = s->mb_y * 16 + (my >> 2);
1921 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1922 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1924 if (v->profile != PROFILE_ADVANCED) {
1925 src_x = av_clip( src_x, -16, s->mb_width * 16);
1926 src_y = av_clip( src_y, -16, s->mb_height * 16);
1927 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1928 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1930 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1931 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1932 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1933 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1936 srcY += src_y * s->linesize + src_x;
1937 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1938 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1940 if (v->field_mode && v->ref_field_type[1]) {
1941 srcY += s->current_picture_ptr->f.linesize[0];
1942 srcU += s->current_picture_ptr->f.linesize[1];
1943 srcV += s->current_picture_ptr->f.linesize[2];
1946 /* for grayscale we should not try to read from unknown area */
1947 if (s->flags & CODEC_FLAG_GRAY) {
1948 srcU = s->edge_emu_buffer + 18 * s->linesize;
1949 srcV = s->edge_emu_buffer + 18 * s->linesize;
1952 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22 || use_ic
1953 || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1954 || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1955 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1957 srcY -= s->mspel * (1 + s->linesize);
1958 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1959 17 + s->mspel * 2, 17 + s->mspel * 2,
1960 src_x - s->mspel, src_y - s->mspel,
1961 s->h_edge_pos, v_edge_pos);
1962 srcY = s->edge_emu_buffer;
1963 s->vdsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1964 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1965 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1966 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1969 /* if we deal with range reduction we need to scale source blocks */
1970 if (v->rangeredfrm) {
1972 uint8_t *src, *src2;
1975 for (j = 0; j < 17 + s->mspel * 2; j++) {
1976 for (i = 0; i < 17 + s->mspel * 2; i++)
1977 src[i] = ((src[i] - 128) >> 1) + 128;
1982 for (j = 0; j < 9; j++) {
1983 for (i = 0; i < 9; i++) {
1984 src[i] = ((src[i] - 128) >> 1) + 128;
1985 src2[i] = ((src2[i] - 128) >> 1) + 128;
1987 src += s->uvlinesize;
1988 src2 += s->uvlinesize;
1993 uint8_t (*luty )[256] = v->next_luty;
1994 uint8_t (*lutuv)[256] = v->next_lutuv;
1996 uint8_t *src, *src2;
1999 for (j = 0; j < 17 + s->mspel * 2; j++) {
2000 int f = v->field_mode ? v->ref_field_type[1] : ((j+src_y - s->mspel) & 1);
2001 for (i = 0; i < 17 + s->mspel * 2; i++)
2002 src[i] = luty[f][src[i]];
2007 for (j = 0; j < 9; j++) {
2008 int f = v->field_mode ? v->ref_field_type[1] : ((j+uvsrc_y) & 1);
2009 for (i = 0; i < 9; i++) {
2010 src[i] = lutuv[f][src[i]];
2011 src2[i] = lutuv[f][src2[i]];
2013 src += s->uvlinesize;
2014 src2 += s->uvlinesize;
2017 srcY += s->mspel * (1 + s->linesize);
2024 dxy = ((my & 3) << 2) | (mx & 3);
2025 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
2026 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
2027 srcY += s->linesize * 8;
2028 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
2029 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
2031 dxy = (my & 2) | ((mx & 2) >> 1);
2034 s->hdsp.avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
2036 s->hdsp.avg_no_rnd_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, 16);
2039 if (s->flags & CODEC_FLAG_GRAY) return;
2040 /* Chroma MC always uses qpel blilinear */
2041 uvmx = (uvmx & 3) << 1;
2042 uvmy = (uvmy & 3) << 1;
2044 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2045 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2047 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2048 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2052 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2056 #if B_FRACTION_DEN==256
2060 return 2 * ((value * n + 255) >> 9);
2061 return (value * n + 128) >> 8;
2064 n -= B_FRACTION_DEN;
2066 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2067 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2071 /** Reconstruct motion vector for B-frame and do motion compensation
2073 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2074 int direct, int mode)
2081 if (mode == BMV_TYPE_INTERPOLATED) {
2087 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2090 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2091 int direct, int mvtype)
2093 MpegEncContext *s = &v->s;
2094 int xy, wrap, off = 0;
2099 const uint8_t *is_intra = v->mb_type[0];
2103 /* scale MV difference to be quad-pel */
2104 dmv_x[0] <<= 1 - s->quarter_sample;
2105 dmv_y[0] <<= 1 - s->quarter_sample;
2106 dmv_x[1] <<= 1 - s->quarter_sample;
2107 dmv_y[1] <<= 1 - s->quarter_sample;
2109 wrap = s->b8_stride;
2110 xy = s->block_index[0];
2113 s->current_picture.motion_val[0][xy + v->blocks_off][0] =
2114 s->current_picture.motion_val[0][xy + v->blocks_off][1] =
2115 s->current_picture.motion_val[1][xy + v->blocks_off][0] =
2116 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
2119 if (!v->field_mode) {
2120 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2121 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2122 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2123 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2125 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2126 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));
2127 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));
2128 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));
2129 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));
2132 s->current_picture.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2133 s->current_picture.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2134 s->current_picture.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2135 s->current_picture.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2139 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2140 C = s->current_picture.motion_val[0][xy - 2];
2141 A = s->current_picture.motion_val[0][xy - wrap * 2];
2142 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2143 B = s->current_picture.motion_val[0][xy - wrap * 2 + off];
2145 if (!s->mb_x) C[0] = C[1] = 0;
2146 if (!s->first_slice_line) { // predictor A is not out of bounds
2147 if (s->mb_width == 1) {
2151 px = mid_pred(A[0], B[0], C[0]);
2152 py = mid_pred(A[1], B[1], C[1]);
2154 } else if (s->mb_x) { // predictor C is not out of bounds
2160 /* Pullback MV as specified in 8.3.5.3.4 */
2163 if (v->profile < PROFILE_ADVANCED) {
2164 qx = (s->mb_x << 5);
2165 qy = (s->mb_y << 5);
2166 X = (s->mb_width << 5) - 4;
2167 Y = (s->mb_height << 5) - 4;
2168 if (qx + px < -28) px = -28 - qx;
2169 if (qy + py < -28) py = -28 - qy;
2170 if (qx + px > X) px = X - qx;
2171 if (qy + py > Y) py = Y - qy;
2173 qx = (s->mb_x << 6);
2174 qy = (s->mb_y << 6);
2175 X = (s->mb_width << 6) - 4;
2176 Y = (s->mb_height << 6) - 4;
2177 if (qx + px < -60) px = -60 - qx;
2178 if (qy + py < -60) py = -60 - qy;
2179 if (qx + px > X) px = X - qx;
2180 if (qy + py > Y) py = Y - qy;
2183 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2184 if (0 && !s->first_slice_line && s->mb_x) {
2185 if (is_intra[xy - wrap])
2186 sum = FFABS(px) + FFABS(py);
2188 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2190 if (get_bits1(&s->gb)) {
2198 if (is_intra[xy - 2])
2199 sum = FFABS(px) + FFABS(py);
2201 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2203 if (get_bits1(&s->gb)) {
2213 /* store MV using signed modulus of MV range defined in 4.11 */
2214 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2215 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2217 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2218 C = s->current_picture.motion_val[1][xy - 2];
2219 A = s->current_picture.motion_val[1][xy - wrap * 2];
2220 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2221 B = s->current_picture.motion_val[1][xy - wrap * 2 + off];
2225 if (!s->first_slice_line) { // predictor A is not out of bounds
2226 if (s->mb_width == 1) {
2230 px = mid_pred(A[0], B[0], C[0]);
2231 py = mid_pred(A[1], B[1], C[1]);
2233 } else if (s->mb_x) { // predictor C is not out of bounds
2239 /* Pullback MV as specified in 8.3.5.3.4 */
2242 if (v->profile < PROFILE_ADVANCED) {
2243 qx = (s->mb_x << 5);
2244 qy = (s->mb_y << 5);
2245 X = (s->mb_width << 5) - 4;
2246 Y = (s->mb_height << 5) - 4;
2247 if (qx + px < -28) px = -28 - qx;
2248 if (qy + py < -28) py = -28 - qy;
2249 if (qx + px > X) px = X - qx;
2250 if (qy + py > Y) py = Y - qy;
2252 qx = (s->mb_x << 6);
2253 qy = (s->mb_y << 6);
2254 X = (s->mb_width << 6) - 4;
2255 Y = (s->mb_height << 6) - 4;
2256 if (qx + px < -60) px = -60 - qx;
2257 if (qy + py < -60) py = -60 - qy;
2258 if (qx + px > X) px = X - qx;
2259 if (qy + py > Y) py = Y - qy;
2262 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2263 if (0 && !s->first_slice_line && s->mb_x) {
2264 if (is_intra[xy - wrap])
2265 sum = FFABS(px) + FFABS(py);
2267 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2269 if (get_bits1(&s->gb)) {
2277 if (is_intra[xy - 2])
2278 sum = FFABS(px) + FFABS(py);
2280 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2282 if (get_bits1(&s->gb)) {
2292 /* store MV using signed modulus of MV range defined in 4.11 */
2294 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2295 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2297 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2298 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2299 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2300 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2303 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2305 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2306 MpegEncContext *s = &v->s;
2307 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2309 if (v->bmvtype == BMV_TYPE_DIRECT) {
2310 int total_opp, k, f;
2311 if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2312 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2313 v->bfraction, 0, s->quarter_sample);
2314 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2315 v->bfraction, 0, s->quarter_sample);
2316 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2317 v->bfraction, 1, s->quarter_sample);
2318 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2319 v->bfraction, 1, s->quarter_sample);
2321 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2322 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2323 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2324 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2325 f = (total_opp > 2) ? 1 : 0;
2327 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2328 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2331 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2332 for (k = 0; k < 4; k++) {
2333 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2334 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2335 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2336 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2337 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2338 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2342 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2343 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);
2344 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);
2347 if (dir) { // backward
2348 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);
2349 if (n == 3 || mv1) {
2350 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2353 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);
2354 if (n == 3 || mv1) {
2355 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2360 /** Get predicted DC value for I-frames only
2361 * prediction dir: left=0, top=1
2362 * @param s MpegEncContext
2363 * @param overlap flag indicating that overlap filtering is used
2364 * @param pq integer part of picture quantizer
2365 * @param[in] n block index in the current MB
2366 * @param dc_val_ptr Pointer to DC predictor
2367 * @param dir_ptr Prediction direction for use in AC prediction
2369 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2370 int16_t **dc_val_ptr, int *dir_ptr)
2372 int a, b, c, wrap, pred, scale;
2374 static const uint16_t dcpred[32] = {
2375 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2376 114, 102, 93, 85, 79, 73, 68, 64,
2377 60, 57, 54, 51, 49, 47, 45, 43,
2378 41, 39, 38, 37, 35, 34, 33
2381 /* find prediction - wmv3_dc_scale always used here in fact */
2382 if (n < 4) scale = s->y_dc_scale;
2383 else scale = s->c_dc_scale;
2385 wrap = s->block_wrap[n];
2386 dc_val = s->dc_val[0] + s->block_index[n];
2392 b = dc_val[ - 1 - wrap];
2393 a = dc_val[ - wrap];
2395 if (pq < 9 || !overlap) {
2396 /* Set outer values */
2397 if (s->first_slice_line && (n != 2 && n != 3))
2398 b = a = dcpred[scale];
2399 if (s->mb_x == 0 && (n != 1 && n != 3))
2400 b = c = dcpred[scale];
2402 /* Set outer values */
2403 if (s->first_slice_line && (n != 2 && n != 3))
2405 if (s->mb_x == 0 && (n != 1 && n != 3))
2409 if (abs(a - b) <= abs(b - c)) {
2411 *dir_ptr = 1; // left
2414 *dir_ptr = 0; // top
2417 /* update predictor */
2418 *dc_val_ptr = &dc_val[0];
2423 /** Get predicted DC value
2424 * prediction dir: left=0, top=1
2425 * @param s MpegEncContext
2426 * @param overlap flag indicating that overlap filtering is used
2427 * @param pq integer part of picture quantizer
2428 * @param[in] n block index in the current MB
2429 * @param a_avail flag indicating top block availability
2430 * @param c_avail flag indicating left block availability
2431 * @param dc_val_ptr Pointer to DC predictor
2432 * @param dir_ptr Prediction direction for use in AC prediction
2434 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2435 int a_avail, int c_avail,
2436 int16_t **dc_val_ptr, int *dir_ptr)
2438 int a, b, c, wrap, pred;
2440 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2444 wrap = s->block_wrap[n];
2445 dc_val = s->dc_val[0] + s->block_index[n];
2451 b = dc_val[ - 1 - wrap];
2452 a = dc_val[ - wrap];
2453 /* scale predictors if needed */
2454 q1 = s->current_picture.qscale_table[mb_pos];
2455 dqscale_index = s->y_dc_scale_table[q1] - 1;
2456 if (dqscale_index < 0)
2458 if (c_avail && (n != 1 && n != 3)) {
2459 q2 = s->current_picture.qscale_table[mb_pos - 1];
2461 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2463 if (a_avail && (n != 2 && n != 3)) {
2464 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2466 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2468 if (a_avail && c_avail && (n != 3)) {
2473 off -= s->mb_stride;
2474 q2 = s->current_picture.qscale_table[off];
2476 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2479 if (a_avail && c_avail) {
2480 if (abs(a - b) <= abs(b - c)) {
2482 *dir_ptr = 1; // left
2485 *dir_ptr = 0; // top
2487 } else if (a_avail) {
2489 *dir_ptr = 0; // top
2490 } else if (c_avail) {
2492 *dir_ptr = 1; // left
2495 *dir_ptr = 1; // left
2498 /* update predictor */
2499 *dc_val_ptr = &dc_val[0];
2503 /** @} */ // Block group
2506 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2507 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2511 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2512 uint8_t **coded_block_ptr)
2514 int xy, wrap, pred, a, b, c;
2516 xy = s->block_index[n];
2517 wrap = s->b8_stride;
2522 a = s->coded_block[xy - 1 ];
2523 b = s->coded_block[xy - 1 - wrap];
2524 c = s->coded_block[xy - wrap];
2533 *coded_block_ptr = &s->coded_block[xy];
2539 * Decode one AC coefficient
2540 * @param v The VC1 context
2541 * @param last Last coefficient
2542 * @param skip How much zero coefficients to skip
2543 * @param value Decoded AC coefficient value
2544 * @param codingset set of VLC to decode data
2547 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2548 int *value, int codingset)
2550 GetBitContext *gb = &v->s.gb;
2551 int index, escape, run = 0, level = 0, lst = 0;
2553 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2554 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2555 run = vc1_index_decode_table[codingset][index][0];
2556 level = vc1_index_decode_table[codingset][index][1];
2557 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2561 escape = decode210(gb);
2563 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2564 run = vc1_index_decode_table[codingset][index][0];
2565 level = vc1_index_decode_table[codingset][index][1];
2566 lst = index >= vc1_last_decode_table[codingset];
2569 level += vc1_last_delta_level_table[codingset][run];
2571 level += vc1_delta_level_table[codingset][run];
2574 run += vc1_last_delta_run_table[codingset][level] + 1;
2576 run += vc1_delta_run_table[codingset][level] + 1;
2582 lst = get_bits1(gb);
2583 if (v->s.esc3_level_length == 0) {
2584 if (v->pq < 8 || v->dquantfrm) { // table 59
2585 v->s.esc3_level_length = get_bits(gb, 3);
2586 if (!v->s.esc3_level_length)
2587 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2588 } else { // table 60
2589 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2591 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2593 run = get_bits(gb, v->s.esc3_run_length);
2594 sign = get_bits1(gb);
2595 level = get_bits(gb, v->s.esc3_level_length);
2606 /** Decode intra block in intra frames - should be faster than decode_intra_block
2607 * @param v VC1Context
2608 * @param block block to decode
2609 * @param[in] n subblock index
2610 * @param coded are AC coeffs present or not
2611 * @param codingset set of VLC to decode data
2613 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
2614 int coded, int codingset)
2616 GetBitContext *gb = &v->s.gb;
2617 MpegEncContext *s = &v->s;
2618 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2621 int16_t *ac_val, *ac_val2;
2624 /* Get DC differential */
2626 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2628 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2631 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2635 if (dcdiff == 119 /* ESC index value */) {
2636 /* TODO: Optimize */
2637 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2638 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2639 else dcdiff = get_bits(gb, 8);
2642 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2643 else if (v->pq == 2)
2644 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2651 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2654 /* Store the quantized DC coeff, used for prediction */
2656 block[0] = dcdiff * s->y_dc_scale;
2658 block[0] = dcdiff * s->c_dc_scale;
2669 int last = 0, skip, value;
2670 const uint8_t *zz_table;
2674 scale = v->pq * 2 + v->halfpq;
2678 zz_table = v->zz_8x8[2];
2680 zz_table = v->zz_8x8[3];
2682 zz_table = v->zz_8x8[1];
2684 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2686 if (dc_pred_dir) // left
2689 ac_val -= 16 * s->block_wrap[n];
2692 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2696 block[zz_table[i++]] = value;
2699 /* apply AC prediction if needed */
2701 if (dc_pred_dir) { // left
2702 for (k = 1; k < 8; k++)
2703 block[k << v->left_blk_sh] += ac_val[k];
2705 for (k = 1; k < 8; k++)
2706 block[k << v->top_blk_sh] += ac_val[k + 8];
2709 /* save AC coeffs for further prediction */
2710 for (k = 1; k < 8; k++) {
2711 ac_val2[k] = block[k << v->left_blk_sh];
2712 ac_val2[k + 8] = block[k << v->top_blk_sh];
2715 /* scale AC coeffs */
2716 for (k = 1; k < 64; k++)
2720 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2723 if (s->ac_pred) i = 63;
2729 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2733 scale = v->pq * 2 + v->halfpq;
2734 memset(ac_val2, 0, 16 * 2);
2735 if (dc_pred_dir) { // left
2738 memcpy(ac_val2, ac_val, 8 * 2);
2740 ac_val -= 16 * s->block_wrap[n];
2742 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2745 /* apply AC prediction if needed */
2747 if (dc_pred_dir) { //left
2748 for (k = 1; k < 8; k++) {
2749 block[k << v->left_blk_sh] = ac_val[k] * scale;
2750 if (!v->pquantizer && block[k << v->left_blk_sh])
2751 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2754 for (k = 1; k < 8; k++) {
2755 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2756 if (!v->pquantizer && block[k << v->top_blk_sh])
2757 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2763 s->block_last_index[n] = i;
2768 /** Decode intra block in intra frames - should be faster than decode_intra_block
2769 * @param v VC1Context
2770 * @param block block to decode
2771 * @param[in] n subblock number
2772 * @param coded are AC coeffs present or not
2773 * @param codingset set of VLC to decode data
2774 * @param mquant quantizer value for this macroblock
2776 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
2777 int coded, int codingset, int mquant)
2779 GetBitContext *gb = &v->s.gb;
2780 MpegEncContext *s = &v->s;
2781 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2784 int16_t *ac_val, *ac_val2;
2786 int a_avail = v->a_avail, c_avail = v->c_avail;
2787 int use_pred = s->ac_pred;
2790 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2792 /* Get DC differential */
2794 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2796 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2799 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2803 if (dcdiff == 119 /* ESC index value */) {
2804 /* TODO: Optimize */
2805 if (mquant == 1) dcdiff = get_bits(gb, 10);
2806 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2807 else dcdiff = get_bits(gb, 8);
2810 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2811 else if (mquant == 2)
2812 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2819 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2822 /* Store the quantized DC coeff, used for prediction */
2824 block[0] = dcdiff * s->y_dc_scale;
2826 block[0] = dcdiff * s->c_dc_scale;
2832 /* check if AC is needed at all */
2833 if (!a_avail && !c_avail)
2835 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2838 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2840 if (dc_pred_dir) // left
2843 ac_val -= 16 * s->block_wrap[n];
2845 q1 = s->current_picture.qscale_table[mb_pos];
2846 if ( dc_pred_dir && c_avail && mb_pos)
2847 q2 = s->current_picture.qscale_table[mb_pos - 1];
2848 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2849 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2850 if ( dc_pred_dir && n == 1)
2852 if (!dc_pred_dir && n == 2)
2858 int last = 0, skip, value;
2859 const uint8_t *zz_table;
2863 if (!use_pred && v->fcm == ILACE_FRAME) {
2864 zz_table = v->zzi_8x8;
2866 if (!dc_pred_dir) // top
2867 zz_table = v->zz_8x8[2];
2869 zz_table = v->zz_8x8[3];
2872 if (v->fcm != ILACE_FRAME)
2873 zz_table = v->zz_8x8[1];
2875 zz_table = v->zzi_8x8;
2879 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2883 block[zz_table[i++]] = value;
2886 /* apply AC prediction if needed */
2888 /* scale predictors if needed*/
2889 if (q2 && q1 != q2) {
2890 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2891 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2894 return AVERROR_INVALIDDATA;
2895 if (dc_pred_dir) { // left
2896 for (k = 1; k < 8; k++)
2897 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2899 for (k = 1; k < 8; k++)
2900 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2903 if (dc_pred_dir) { //left
2904 for (k = 1; k < 8; k++)
2905 block[k << v->left_blk_sh] += ac_val[k];
2907 for (k = 1; k < 8; k++)
2908 block[k << v->top_blk_sh] += ac_val[k + 8];
2912 /* save AC coeffs for further prediction */
2913 for (k = 1; k < 8; k++) {
2914 ac_val2[k ] = block[k << v->left_blk_sh];
2915 ac_val2[k + 8] = block[k << v->top_blk_sh];
2918 /* scale AC coeffs */
2919 for (k = 1; k < 64; k++)
2923 block[k] += (block[k] < 0) ? -mquant : mquant;
2926 if (use_pred) i = 63;
2927 } else { // no AC coeffs
2930 memset(ac_val2, 0, 16 * 2);
2931 if (dc_pred_dir) { // left
2933 memcpy(ac_val2, ac_val, 8 * 2);
2934 if (q2 && q1 != q2) {
2935 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2936 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2938 return AVERROR_INVALIDDATA;
2939 for (k = 1; k < 8; k++)
2940 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2945 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2946 if (q2 && q1 != q2) {
2947 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2948 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2950 return AVERROR_INVALIDDATA;
2951 for (k = 1; k < 8; k++)
2952 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2957 /* apply AC prediction if needed */
2959 if (dc_pred_dir) { // left
2960 for (k = 1; k < 8; k++) {
2961 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2962 if (!v->pquantizer && block[k << v->left_blk_sh])
2963 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2966 for (k = 1; k < 8; k++) {
2967 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2968 if (!v->pquantizer && block[k << v->top_blk_sh])
2969 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2975 s->block_last_index[n] = i;
2980 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2981 * @param v VC1Context
2982 * @param block block to decode
2983 * @param[in] n subblock index
2984 * @param coded are AC coeffs present or not
2985 * @param mquant block quantizer
2986 * @param codingset set of VLC to decode data
2988 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
2989 int coded, int mquant, int codingset)
2991 GetBitContext *gb = &v->s.gb;
2992 MpegEncContext *s = &v->s;
2993 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2996 int16_t *ac_val, *ac_val2;
2998 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2999 int a_avail = v->a_avail, c_avail = v->c_avail;
3000 int use_pred = s->ac_pred;
3004 s->dsp.clear_block(block);
3006 /* XXX: Guard against dumb values of mquant */
3007 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
3009 /* Set DC scale - y and c use the same */
3010 s->y_dc_scale = s->y_dc_scale_table[mquant];
3011 s->c_dc_scale = s->c_dc_scale_table[mquant];
3013 /* Get DC differential */
3015 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3017 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3020 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3024 if (dcdiff == 119 /* ESC index value */) {
3025 /* TODO: Optimize */
3026 if (mquant == 1) dcdiff = get_bits(gb, 10);
3027 else if (mquant == 2) dcdiff = get_bits(gb, 9);
3028 else dcdiff = get_bits(gb, 8);
3031 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
3032 else if (mquant == 2)
3033 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
3040 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3043 /* Store the quantized DC coeff, used for prediction */
3046 block[0] = dcdiff * s->y_dc_scale;
3048 block[0] = dcdiff * s->c_dc_scale;
3054 /* check if AC is needed at all and adjust direction if needed */
3055 if (!a_avail) dc_pred_dir = 1;
3056 if (!c_avail) dc_pred_dir = 0;
3057 if (!a_avail && !c_avail) use_pred = 0;
3058 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3061 scale = mquant * 2 + v->halfpq;
3063 if (dc_pred_dir) //left
3066 ac_val -= 16 * s->block_wrap[n];
3068 q1 = s->current_picture.qscale_table[mb_pos];
3069 if (dc_pred_dir && c_avail && mb_pos)
3070 q2 = s->current_picture.qscale_table[mb_pos - 1];
3071 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3072 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3073 if ( dc_pred_dir && n == 1)
3075 if (!dc_pred_dir && n == 2)
3077 if (n == 3) q2 = q1;
3080 int last = 0, skip, value;
3084 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3088 if (v->fcm == PROGRESSIVE)
3089 block[v->zz_8x8[0][i++]] = value;
3091 if (use_pred && (v->fcm == ILACE_FRAME)) {
3092 if (!dc_pred_dir) // top
3093 block[v->zz_8x8[2][i++]] = value;
3095 block[v->zz_8x8[3][i++]] = value;
3097 block[v->zzi_8x8[i++]] = value;
3102 /* apply AC prediction if needed */
3104 /* scale predictors if needed*/
3105 if (q2 && q1 != q2) {
3106 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3107 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3110 return AVERROR_INVALIDDATA;
3111 if (dc_pred_dir) { // left
3112 for (k = 1; k < 8; k++)
3113 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3115 for (k = 1; k < 8; k++)
3116 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3119 if (dc_pred_dir) { // left
3120 for (k = 1; k < 8; k++)
3121 block[k << v->left_blk_sh] += ac_val[k];
3123 for (k = 1; k < 8; k++)
3124 block[k << v->top_blk_sh] += ac_val[k + 8];
3128 /* save AC coeffs for further prediction */
3129 for (k = 1; k < 8; k++) {
3130 ac_val2[k ] = block[k << v->left_blk_sh];
3131 ac_val2[k + 8] = block[k << v->top_blk_sh];
3134 /* scale AC coeffs */
3135 for (k = 1; k < 64; k++)
3139 block[k] += (block[k] < 0) ? -mquant : mquant;
3142 if (use_pred) i = 63;
3143 } else { // no AC coeffs
3146 memset(ac_val2, 0, 16 * 2);
3147 if (dc_pred_dir) { // left
3149 memcpy(ac_val2, ac_val, 8 * 2);
3150 if (q2 && q1 != q2) {
3151 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3152 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3154 return AVERROR_INVALIDDATA;
3155 for (k = 1; k < 8; k++)
3156 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3161 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3162 if (q2 && q1 != q2) {
3163 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3164 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3166 return AVERROR_INVALIDDATA;
3167 for (k = 1; k < 8; k++)
3168 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3173 /* apply AC prediction if needed */
3175 if (dc_pred_dir) { // left
3176 for (k = 1; k < 8; k++) {
3177 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3178 if (!v->pquantizer && block[k << v->left_blk_sh])
3179 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3182 for (k = 1; k < 8; k++) {
3183 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3184 if (!v->pquantizer && block[k << v->top_blk_sh])
3185 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3191 s->block_last_index[n] = i;
3198 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
3199 int mquant, int ttmb, int first_block,
3200 uint8_t *dst, int linesize, int skip_block,
3203 MpegEncContext *s = &v->s;
3204 GetBitContext *gb = &s->gb;
3207 int scale, off, idx, last, skip, value;
3208 int ttblk = ttmb & 7;
3211 s->dsp.clear_block(block);
3214 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)];
3216 if (ttblk == TT_4X4) {
3217 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3219 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3220 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3221 || (!v->res_rtm_flag && !first_block))) {
3222 subblkpat = decode012(gb);
3224 subblkpat ^= 3; // swap decoded pattern bits
3225 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3227 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3230 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3232 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3233 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3234 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3237 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3238 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3247 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3252 idx = v->zz_8x8[0][i++];
3254 idx = v->zzi_8x8[i++];
3255 block[idx] = value * scale;
3257 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3261 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3263 v->vc1dsp.vc1_inv_trans_8x8(block);
3264 s->dsp.add_pixels_clamped(block, dst, linesize);
3269 pat = ~subblkpat & 0xF;
3270 for (j = 0; j < 4; j++) {
3271 last = subblkpat & (1 << (3 - j));
3273 off = (j & 1) * 4 + (j & 2) * 16;
3275 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3280 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3282 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3283 block[idx + off] = value * scale;
3285 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3287 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3289 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3291 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3296 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3297 for (j = 0; j < 2; j++) {
3298 last = subblkpat & (1 << (1 - j));
3302 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3307 idx = v->zz_8x4[i++] + off;
3309 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3310 block[idx] = value * scale;
3312 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3314 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3316 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3318 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3323 pat = ~(subblkpat * 5) & 0xF;
3324 for (j = 0; j < 2; j++) {
3325 last = subblkpat & (1 << (1 - j));
3329 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3334 idx = v->zz_4x8[i++] + off;
3336 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3337 block[idx] = value * scale;
3339 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3341 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3343 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3345 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3351 *ttmb_out |= ttblk << (n * 4);
3355 /** @} */ // Macroblock group
3357 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3358 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3360 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3362 MpegEncContext *s = &v->s;
3363 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3364 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3365 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3366 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3367 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3370 if (block_num > 3) {
3371 dst = s->dest[block_num - 3];
3373 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3375 if (s->mb_y != s->end_mb_y || block_num < 2) {
3379 if (block_num > 3) {
3380 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3381 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3382 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3383 mv_stride = s->mb_stride;
3385 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3386 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3387 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3388 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3389 mv_stride = s->b8_stride;
3390 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3393 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3394 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3395 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3397 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3399 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3402 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3404 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3409 dst -= 4 * linesize;
3410 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3411 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3412 idx = (block_cbp | (block_cbp >> 2)) & 3;
3414 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3417 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3419 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3424 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3426 MpegEncContext *s = &v->s;
3427 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3428 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3429 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3430 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3431 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3434 if (block_num > 3) {
3435 dst = s->dest[block_num - 3] - 8 * linesize;
3437 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3440 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3443 if (block_num > 3) {
3444 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3445 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3446 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3448 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3449 : (mb_cbp >> ((block_num + 1) * 4));
3450 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3451 : (mb_is_intra >> ((block_num + 1) * 4));
3452 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3454 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3455 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3457 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3459 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3462 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3464 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3470 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3471 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3472 idx = (block_cbp | (block_cbp >> 1)) & 5;
3474 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3477 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3479 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3484 static void vc1_apply_p_loop_filter(VC1Context *v)
3486 MpegEncContext *s = &v->s;
3489 for (i = 0; i < 6; i++) {
3490 vc1_apply_p_v_loop_filter(v, i);
3493 /* V always precedes H, therefore we run H one MB before V;
3494 * at the end of a row, we catch up to complete the row */
3496 for (i = 0; i < 6; i++) {
3497 vc1_apply_p_h_loop_filter(v, i);
3499 if (s->mb_x == s->mb_width - 1) {
3501 ff_update_block_index(s);
3502 for (i = 0; i < 6; i++) {
3503 vc1_apply_p_h_loop_filter(v, i);
3509 /** Decode one P-frame MB
3511 static int vc1_decode_p_mb(VC1Context *v)
3513 MpegEncContext *s = &v->s;
3514 GetBitContext *gb = &s->gb;
3516 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3517 int cbp; /* cbp decoding stuff */
3518 int mqdiff, mquant; /* MB quantization */
3519 int ttmb = v->ttfrm; /* MB Transform type */
3521 int mb_has_coeffs = 1; /* last_flag */
3522 int dmv_x, dmv_y; /* Differential MV components */
3523 int index, index1; /* LUT indexes */
3524 int val, sign; /* temp values */
3525 int first_block = 1;
3527 int skipped, fourmv;
3528 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3530 mquant = v->pq; /* lossy initialization */
3532 if (v->mv_type_is_raw)
3533 fourmv = get_bits1(gb);
3535 fourmv = v->mv_type_mb_plane[mb_pos];
3537 skipped = get_bits1(gb);
3539 skipped = v->s.mbskip_table[mb_pos];
3541 if (!fourmv) { /* 1MV mode */
3543 GET_MVDATA(dmv_x, dmv_y);
3546 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3547 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3549 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3550 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3552 /* FIXME Set DC val for inter block ? */
3553 if (s->mb_intra && !mb_has_coeffs) {
3555 s->ac_pred = get_bits1(gb);
3557 } else if (mb_has_coeffs) {
3559 s->ac_pred = get_bits1(gb);
3560 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3566 s->current_picture.qscale_table[mb_pos] = mquant;
3568 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3569 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3570 VC1_TTMB_VLC_BITS, 2);
3571 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3573 for (i = 0; i < 6; i++) {
3574 s->dc_val[0][s->block_index[i]] = 0;
3576 val = ((cbp >> (5 - i)) & 1);
3577 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3578 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3580 /* check if prediction blocks A and C are available */
3581 v->a_avail = v->c_avail = 0;
3582 if (i == 2 || i == 3 || !s->first_slice_line)
3583 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3584 if (i == 1 || i == 3 || s->mb_x)
3585 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3587 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3588 (i & 4) ? v->codingset2 : v->codingset);
3589 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3591 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3593 for (j = 0; j < 64; j++)
3594 s->block[i][j] <<= 1;
3595 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3596 if (v->pq >= 9 && v->overlap) {
3598 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3600 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3602 block_cbp |= 0xF << (i << 2);
3603 block_intra |= 1 << i;
3605 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3606 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3607 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3608 block_cbp |= pat << (i << 2);
3609 if (!v->ttmbf && ttmb < 8)
3616 for (i = 0; i < 6; i++) {
3617 v->mb_type[0][s->block_index[i]] = 0;
3618 s->dc_val[0][s->block_index[i]] = 0;
3620 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3621 s->current_picture.qscale_table[mb_pos] = 0;
3622 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3625 } else { // 4MV mode
3626 if (!skipped /* unskipped MB */) {
3627 int intra_count = 0, coded_inter = 0;
3628 int is_intra[6], is_coded[6];
3630 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3631 for (i = 0; i < 6; i++) {
3632 val = ((cbp >> (5 - i)) & 1);
3633 s->dc_val[0][s->block_index[i]] = 0;
3640 GET_MVDATA(dmv_x, dmv_y);
3642 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3644 vc1_mc_4mv_luma(v, i, 0, 0);
3645 intra_count += s->mb_intra;
3646 is_intra[i] = s->mb_intra;
3647 is_coded[i] = mb_has_coeffs;
3650 is_intra[i] = (intra_count >= 3);
3654 vc1_mc_4mv_chroma(v, 0);
3655 v->mb_type[0][s->block_index[i]] = is_intra[i];
3657 coded_inter = !is_intra[i] & is_coded[i];
3659 // if there are no coded blocks then don't do anything more
3661 if (!intra_count && !coded_inter)
3664 s->current_picture.qscale_table[mb_pos] = mquant;
3665 /* test if block is intra and has pred */
3668 for (i = 0; i < 6; i++)
3670 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3671 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3677 s->ac_pred = get_bits1(gb);
3681 if (!v->ttmbf && coded_inter)
3682 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3683 for (i = 0; i < 6; i++) {
3685 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3686 s->mb_intra = is_intra[i];
3688 /* check if prediction blocks A and C are available */
3689 v->a_avail = v->c_avail = 0;
3690 if (i == 2 || i == 3 || !s->first_slice_line)
3691 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3692 if (i == 1 || i == 3 || s->mb_x)
3693 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3695 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3696 (i & 4) ? v->codingset2 : v->codingset);
3697 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3699 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3701 for (j = 0; j < 64; j++)
3702 s->block[i][j] <<= 1;
3703 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3704 (i & 4) ? s->uvlinesize : s->linesize);
3705 if (v->pq >= 9 && v->overlap) {
3707 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3709 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3711 block_cbp |= 0xF << (i << 2);
3712 block_intra |= 1 << i;
3713 } else if (is_coded[i]) {
3714 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3715 first_block, s->dest[dst_idx] + off,
3716 (i & 4) ? s->uvlinesize : s->linesize,
3717 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3719 block_cbp |= pat << (i << 2);
3720 if (!v->ttmbf && ttmb < 8)
3725 } else { // skipped MB
3727 s->current_picture.qscale_table[mb_pos] = 0;
3728 for (i = 0; i < 6; i++) {
3729 v->mb_type[0][s->block_index[i]] = 0;
3730 s->dc_val[0][s->block_index[i]] = 0;
3732 for (i = 0; i < 4; i++) {
3733 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3734 vc1_mc_4mv_luma(v, i, 0, 0);
3736 vc1_mc_4mv_chroma(v, 0);
3737 s->current_picture.qscale_table[mb_pos] = 0;
3741 v->cbp[s->mb_x] = block_cbp;
3742 v->ttblk[s->mb_x] = block_tt;
3743 v->is_intra[s->mb_x] = block_intra;
3748 /* Decode one macroblock in an interlaced frame p picture */
3750 static int vc1_decode_p_mb_intfr(VC1Context *v)
3752 MpegEncContext *s = &v->s;
3753 GetBitContext *gb = &s->gb;
3755 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3756 int cbp = 0; /* cbp decoding stuff */
3757 int mqdiff, mquant; /* MB quantization */
3758 int ttmb = v->ttfrm; /* MB Transform type */
3760 int mb_has_coeffs = 1; /* last_flag */
3761 int dmv_x, dmv_y; /* Differential MV components */
3762 int val; /* temp value */
3763 int first_block = 1;
3765 int skipped, fourmv = 0, twomv = 0;
3766 int block_cbp = 0, pat, block_tt = 0;
3767 int idx_mbmode = 0, mvbp;
3768 int stride_y, fieldtx;
3770 mquant = v->pq; /* Loosy initialization */
3773 skipped = get_bits1(gb);
3775 skipped = v->s.mbskip_table[mb_pos];
3777 if (v->fourmvswitch)
3778 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3780 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3781 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3782 /* store the motion vector type in a flag (useful later) */
3783 case MV_PMODE_INTFR_4MV:
3785 v->blk_mv_type[s->block_index[0]] = 0;
3786 v->blk_mv_type[s->block_index[1]] = 0;
3787 v->blk_mv_type[s->block_index[2]] = 0;
3788 v->blk_mv_type[s->block_index[3]] = 0;
3790 case MV_PMODE_INTFR_4MV_FIELD:
3792 v->blk_mv_type[s->block_index[0]] = 1;
3793 v->blk_mv_type[s->block_index[1]] = 1;
3794 v->blk_mv_type[s->block_index[2]] = 1;
3795 v->blk_mv_type[s->block_index[3]] = 1;
3797 case MV_PMODE_INTFR_2MV_FIELD:
3799 v->blk_mv_type[s->block_index[0]] = 1;
3800 v->blk_mv_type[s->block_index[1]] = 1;
3801 v->blk_mv_type[s->block_index[2]] = 1;
3802 v->blk_mv_type[s->block_index[3]] = 1;
3804 case MV_PMODE_INTFR_1MV:
3805 v->blk_mv_type[s->block_index[0]] = 0;
3806 v->blk_mv_type[s->block_index[1]] = 0;
3807 v->blk_mv_type[s->block_index[2]] = 0;
3808 v->blk_mv_type[s->block_index[3]] = 0;
3811 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3812 for (i = 0; i < 4; i++) {
3813 s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
3814 s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
3816 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3817 s->mb_intra = v->is_intra[s->mb_x] = 1;
3818 for (i = 0; i < 6; i++)
3819 v->mb_type[0][s->block_index[i]] = 1;
3820 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3821 mb_has_coeffs = get_bits1(gb);
3823 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3824 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3826 s->current_picture.qscale_table[mb_pos] = mquant;
3827 /* Set DC scale - y and c use the same (not sure if necessary here) */
3828 s->y_dc_scale = s->y_dc_scale_table[mquant];
3829 s->c_dc_scale = s->c_dc_scale_table[mquant];
3831 for (i = 0; i < 6; i++) {
3832 s->dc_val[0][s->block_index[i]] = 0;
3834 val = ((cbp >> (5 - i)) & 1);
3835 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3836 v->a_avail = v->c_avail = 0;
3837 if (i == 2 || i == 3 || !s->first_slice_line)
3838 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3839 if (i == 1 || i == 3 || s->mb_x)
3840 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3842 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3843 (i & 4) ? v->codingset2 : v->codingset);
3844 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3845 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3847 stride_y = s->linesize << fieldtx;
3848 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3850 stride_y = s->uvlinesize;
3853 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3857 } else { // inter MB
3858 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3860 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3861 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3862 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3864 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3865 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3866 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3869 s->mb_intra = v->is_intra[s->mb_x] = 0;
3870 for (i = 0; i < 6; i++)
3871 v->mb_type[0][s->block_index[i]] = 0;
3872 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3873 /* for all motion vector read MVDATA and motion compensate each block */
3877 for (i = 0; i < 6; i++) {
3880 val = ((mvbp >> (3 - i)) & 1);
3882 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3884 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0);
3885 vc1_mc_4mv_luma(v, i, 0, 0);
3886 } else if (i == 4) {
3887 vc1_mc_4mv_chroma4(v, 0, 0, 0);
3894 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3896 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3897 vc1_mc_4mv_luma(v, 0, 0, 0);
3898 vc1_mc_4mv_luma(v, 1, 0, 0);
3901 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3903 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3904 vc1_mc_4mv_luma(v, 2, 0, 0);
3905 vc1_mc_4mv_luma(v, 3, 0, 0);
3906 vc1_mc_4mv_chroma4(v, 0, 0, 0);
3908 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3911 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3913 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3917 GET_MQUANT(); // p. 227
3918 s->current_picture.qscale_table[mb_pos] = mquant;
3919 if (!v->ttmbf && cbp)
3920 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3921 for (i = 0; i < 6; i++) {
3922 s->dc_val[0][s->block_index[i]] = 0;
3924 val = ((cbp >> (5 - i)) & 1);
3926 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3928 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3930 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3931 first_block, s->dest[dst_idx] + off,
3932 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3933 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3934 block_cbp |= pat << (i << 2);
3935 if (!v->ttmbf && ttmb < 8)
3942 s->mb_intra = v->is_intra[s->mb_x] = 0;
3943 for (i = 0; i < 6; i++) {
3944 v->mb_type[0][s->block_index[i]] = 0;
3945 s->dc_val[0][s->block_index[i]] = 0;
3947 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3948 s->current_picture.qscale_table[mb_pos] = 0;
3949 v->blk_mv_type[s->block_index[0]] = 0;
3950 v->blk_mv_type[s->block_index[1]] = 0;
3951 v->blk_mv_type[s->block_index[2]] = 0;
3952 v->blk_mv_type[s->block_index[3]] = 0;
3953 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3956 if (s->mb_x == s->mb_width - 1)
3957 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3961 static int vc1_decode_p_mb_intfi(VC1Context *v)
3963 MpegEncContext *s = &v->s;
3964 GetBitContext *gb = &s->gb;
3966 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3967 int cbp = 0; /* cbp decoding stuff */
3968 int mqdiff, mquant; /* MB quantization */
3969 int ttmb = v->ttfrm; /* MB Transform type */
3971 int mb_has_coeffs = 1; /* last_flag */
3972 int dmv_x, dmv_y; /* Differential MV components */
3973 int val; /* temp values */
3974 int first_block = 1;
3977 int block_cbp = 0, pat, block_tt = 0;
3980 mquant = v->pq; /* Loosy initialization */
3982 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3983 if (idx_mbmode <= 1) { // intra MB
3984 s->mb_intra = v->is_intra[s->mb_x] = 1;
3985 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3986 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3987 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3989 s->current_picture.qscale_table[mb_pos] = mquant;
3990 /* Set DC scale - y and c use the same (not sure if necessary here) */
3991 s->y_dc_scale = s->y_dc_scale_table[mquant];
3992 s->c_dc_scale = s->c_dc_scale_table[mquant];
3993 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3994 mb_has_coeffs = idx_mbmode & 1;
3996 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3998 for (i = 0; i < 6; i++) {
3999 s->dc_val[0][s->block_index[i]] = 0;
4000 v->mb_type[0][s->block_index[i]] = 1;
4002 val = ((cbp >> (5 - i)) & 1);
4003 v->a_avail = v->c_avail = 0;
4004 if (i == 2 || i == 3 || !s->first_slice_line)
4005 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4006 if (i == 1 || i == 3 || s->mb_x)
4007 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4009 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4010 (i & 4) ? v->codingset2 : v->codingset);
4011 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4013 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4014 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4015 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4016 // TODO: loop filter
4019 s->mb_intra = v->is_intra[s->mb_x] = 0;
4020 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4021 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4022 if (idx_mbmode <= 5) { // 1-MV
4023 dmv_x = dmv_y = pred_flag = 0;
4024 if (idx_mbmode & 1) {
4025 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4027 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4029 mb_has_coeffs = !(idx_mbmode & 2);
4031 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4032 for (i = 0; i < 6; i++) {
4034 dmv_x = dmv_y = pred_flag = 0;
4035 val = ((v->fourmvbp >> (3 - i)) & 1);
4037 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4039 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4040 vc1_mc_4mv_luma(v, i, 0, 0);
4042 vc1_mc_4mv_chroma(v, 0);
4044 mb_has_coeffs = idx_mbmode & 1;
4047 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4051 s->current_picture.qscale_table[mb_pos] = mquant;
4052 if (!v->ttmbf && cbp) {
4053 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4056 for (i = 0; i < 6; i++) {
4057 s->dc_val[0][s->block_index[i]] = 0;
4059 val = ((cbp >> (5 - i)) & 1);
4060 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4062 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4063 first_block, s->dest[dst_idx] + off,
4064 (i & 4) ? s->uvlinesize : s->linesize,
4065 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
4067 block_cbp |= pat << (i << 2);
4068 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4073 if (s->mb_x == s->mb_width - 1)
4074 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4078 /** Decode one B-frame MB (in Main profile)
4080 static void vc1_decode_b_mb(VC1Context *v)
4082 MpegEncContext *s = &v->s;
4083 GetBitContext *gb = &s->gb;
4085 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4086 int cbp = 0; /* cbp decoding stuff */
4087 int mqdiff, mquant; /* MB quantization */
4088 int ttmb = v->ttfrm; /* MB Transform type */
4089 int mb_has_coeffs = 0; /* last_flag */
4090 int index, index1; /* LUT indexes */
4091 int val, sign; /* temp values */
4092 int first_block = 1;
4094 int skipped, direct;
4095 int dmv_x[2], dmv_y[2];
4096 int bmvtype = BMV_TYPE_BACKWARD;
4098 mquant = v->pq; /* lossy initialization */
4102 direct = get_bits1(gb);
4104 direct = v->direct_mb_plane[mb_pos];
4106 skipped = get_bits1(gb);
4108 skipped = v->s.mbskip_table[mb_pos];
4110 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4111 for (i = 0; i < 6; i++) {
4112 v->mb_type[0][s->block_index[i]] = 0;
4113 s->dc_val[0][s->block_index[i]] = 0;
4115 s->current_picture.qscale_table[mb_pos] = 0;
4119 GET_MVDATA(dmv_x[0], dmv_y[0]);
4120 dmv_x[1] = dmv_x[0];
4121 dmv_y[1] = dmv_y[0];
4123 if (skipped || !s->mb_intra) {
4124 bmvtype = decode012(gb);
4127 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4130 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4133 bmvtype = BMV_TYPE_INTERPOLATED;
4134 dmv_x[0] = dmv_y[0] = 0;
4138 for (i = 0; i < 6; i++)
4139 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4143 bmvtype = BMV_TYPE_INTERPOLATED;
4144 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4145 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4149 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4152 s->current_picture.qscale_table[mb_pos] = mquant;
4154 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4155 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4156 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4157 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4159 if (!mb_has_coeffs && !s->mb_intra) {
4160 /* no coded blocks - effectively skipped */
4161 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4162 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4165 if (s->mb_intra && !mb_has_coeffs) {
4167 s->current_picture.qscale_table[mb_pos] = mquant;
4168 s->ac_pred = get_bits1(gb);
4170 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4172 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4173 GET_MVDATA(dmv_x[0], dmv_y[0]);
4174 if (!mb_has_coeffs) {
4175 /* interpolated skipped block */
4176 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4177 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4181 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4183 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4186 s->ac_pred = get_bits1(gb);
4187 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4189 s->current_picture.qscale_table[mb_pos] = mquant;
4190 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4191 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4195 for (i = 0; i < 6; i++) {
4196 s->dc_val[0][s->block_index[i]] = 0;
4198 val = ((cbp >> (5 - i)) & 1);
4199 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4200 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4202 /* check if prediction blocks A and C are available */
4203 v->a_avail = v->c_avail = 0;
4204 if (i == 2 || i == 3 || !s->first_slice_line)
4205 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4206 if (i == 1 || i == 3 || s->mb_x)
4207 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4209 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4210 (i & 4) ? v->codingset2 : v->codingset);
4211 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4213 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4215 for (j = 0; j < 64; j++)
4216 s->block[i][j] <<= 1;
4217 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4219 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4220 first_block, s->dest[dst_idx] + off,
4221 (i & 4) ? s->uvlinesize : s->linesize,
4222 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4223 if (!v->ttmbf && ttmb < 8)
4230 /** Decode one B-frame MB (in interlaced field B picture)
4232 static void vc1_decode_b_mb_intfi(VC1Context *v)
4234 MpegEncContext *s = &v->s;
4235 GetBitContext *gb = &s->gb;
4237 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4238 int cbp = 0; /* cbp decoding stuff */
4239 int mqdiff, mquant; /* MB quantization */
4240 int ttmb = v->ttfrm; /* MB Transform type */
4241 int mb_has_coeffs = 0; /* last_flag */
4242 int val; /* temp value */
4243 int first_block = 1;
4246 int dmv_x[2], dmv_y[2], pred_flag[2];
4247 int bmvtype = BMV_TYPE_BACKWARD;
4248 int idx_mbmode, interpmvp;
4250 mquant = v->pq; /* Loosy initialization */
4253 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4254 if (idx_mbmode <= 1) { // intra MB
4255 s->mb_intra = v->is_intra[s->mb_x] = 1;
4256 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4257 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4258 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4260 s->current_picture.qscale_table[mb_pos] = mquant;
4261 /* Set DC scale - y and c use the same (not sure if necessary here) */
4262 s->y_dc_scale = s->y_dc_scale_table[mquant];
4263 s->c_dc_scale = s->c_dc_scale_table[mquant];
4264 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4265 mb_has_coeffs = idx_mbmode & 1;
4267 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4269 for (i = 0; i < 6; i++) {
4270 s->dc_val[0][s->block_index[i]] = 0;
4272 val = ((cbp >> (5 - i)) & 1);
4273 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4274 v->a_avail = v->c_avail = 0;
4275 if (i == 2 || i == 3 || !s->first_slice_line)
4276 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4277 if (i == 1 || i == 3 || s->mb_x)
4278 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4280 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4281 (i & 4) ? v->codingset2 : v->codingset);
4282 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4284 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4286 for (j = 0; j < 64; j++)
4287 s->block[i][j] <<= 1;
4288 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4289 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4290 // TODO: yet to perform loop filter
4293 s->mb_intra = v->is_intra[s->mb_x] = 0;
4294 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4295 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4297 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4299 fwd = v->forward_mb_plane[mb_pos];
4300 if (idx_mbmode <= 5) { // 1-MV
4301 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4302 pred_flag[0] = pred_flag[1] = 0;
4304 bmvtype = BMV_TYPE_FORWARD;
4306 bmvtype = decode012(gb);
4309 bmvtype = BMV_TYPE_BACKWARD;
4312 bmvtype = BMV_TYPE_DIRECT;
4315 bmvtype = BMV_TYPE_INTERPOLATED;
4316 interpmvp = get_bits1(gb);
4319 v->bmvtype = bmvtype;
4320 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4321 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4323 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4324 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4326 if (bmvtype == BMV_TYPE_DIRECT) {
4327 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4328 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4330 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4331 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4332 mb_has_coeffs = !(idx_mbmode & 2);
4335 bmvtype = BMV_TYPE_FORWARD;
4336 v->bmvtype = bmvtype;
4337 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4338 for (i = 0; i < 6; i++) {
4340 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4341 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4342 val = ((v->fourmvbp >> (3 - i)) & 1);
4344 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4345 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4346 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4348 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4349 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD, 0);
4351 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4353 mb_has_coeffs = idx_mbmode & 1;
4356 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4360 s->current_picture.qscale_table[mb_pos] = mquant;
4361 if (!v->ttmbf && cbp) {
4362 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4365 for (i = 0; i < 6; i++) {
4366 s->dc_val[0][s->block_index[i]] = 0;
4368 val = ((cbp >> (5 - i)) & 1);
4369 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4371 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4372 first_block, s->dest[dst_idx] + off,
4373 (i & 4) ? s->uvlinesize : s->linesize,
4374 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4375 if (!v->ttmbf && ttmb < 8)
4383 /** Decode one B-frame MB (in interlaced frame B picture)
4385 static int vc1_decode_b_mb_intfr(VC1Context *v)
4387 MpegEncContext *s = &v->s;
4388 GetBitContext *gb = &s->gb;
4390 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4391 int cbp = 0; /* cbp decoding stuff */
4392 int mqdiff, mquant; /* MB quantization */
4393 int ttmb = v->ttfrm; /* MB Transform type */
4394 int mvsw = 0; /* motion vector switch */
4395 int mb_has_coeffs = 1; /* last_flag */
4396 int dmv_x, dmv_y; /* Differential MV components */
4397 int val; /* temp value */
4398 int first_block = 1;
4400 int skipped, direct, twomv = 0;
4401 int block_cbp = 0, pat, block_tt = 0;
4402 int idx_mbmode = 0, mvbp;
4403 int stride_y, fieldtx;
4404 int bmvtype = BMV_TYPE_BACKWARD;
4407 mquant = v->pq; /* Lossy initialization */
4410 skipped = get_bits1(gb);
4412 skipped = v->s.mbskip_table[mb_pos];
4415 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
4416 if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
4418 v->blk_mv_type[s->block_index[0]] = 1;
4419 v->blk_mv_type[s->block_index[1]] = 1;
4420 v->blk_mv_type[s->block_index[2]] = 1;
4421 v->blk_mv_type[s->block_index[3]] = 1;
4423 v->blk_mv_type[s->block_index[0]] = 0;
4424 v->blk_mv_type[s->block_index[1]] = 0;
4425 v->blk_mv_type[s->block_index[2]] = 0;
4426 v->blk_mv_type[s->block_index[3]] = 0;
4431 direct = get_bits1(gb);
4433 direct = v->direct_mb_plane[mb_pos];
4436 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);
4437 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);
4438 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);
4439 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);
4442 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);
4443 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);
4444 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);
4445 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);
4447 for (i = 1; i < 4; i += 2) {
4448 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
4449 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
4450 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
4451 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
4454 for (i = 1; i < 4; i++) {
4455 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
4456 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
4457 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
4458 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
4463 if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
4464 for (i = 0; i < 4; i++) {
4465 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;
4466 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;
4467 s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
4468 s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
4470 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4471 s->mb_intra = v->is_intra[s->mb_x] = 1;
4472 for (i = 0; i < 6; i++)
4473 v->mb_type[0][s->block_index[i]] = 1;
4474 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
4475 mb_has_coeffs = get_bits1(gb);
4477 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4478 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4480 s->current_picture.qscale_table[mb_pos] = mquant;
4481 /* Set DC scale - y and c use the same (not sure if necessary here) */
4482 s->y_dc_scale = s->y_dc_scale_table[mquant];
4483 s->c_dc_scale = s->c_dc_scale_table[mquant];
4485 for (i = 0; i < 6; i++) {
4486 s->dc_val[0][s->block_index[i]] = 0;
4488 val = ((cbp >> (5 - i)) & 1);
4489 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4490 v->a_avail = v->c_avail = 0;
4491 if (i == 2 || i == 3 || !s->first_slice_line)
4492 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4493 if (i == 1 || i == 3 || s->mb_x)
4494 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4496 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4497 (i & 4) ? v->codingset2 : v->codingset);
4498 if (i > 3 && (s->flags & CODEC_FLAG_GRAY))
4500 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4502 stride_y = s->linesize << fieldtx;
4503 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
4505 stride_y = s->uvlinesize;
4508 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
4511 s->mb_intra = v->is_intra[s->mb_x] = 0;
4513 if (skipped || !s->mb_intra) {
4514 bmvtype = decode012(gb);
4517 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4520 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4523 bmvtype = BMV_TYPE_INTERPOLATED;
4527 if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
4528 mvsw = get_bits1(gb);
4531 if (!skipped) { // inter MB
4532 mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
4534 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4536 if (bmvtype == BMV_TYPE_INTERPOLATED & twomv) {
4537 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4538 } else if (bmvtype == BMV_TYPE_INTERPOLATED | twomv) {
4539 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
4543 for (i = 0; i < 6; i++)
4544 v->mb_type[0][s->block_index[i]] = 0;
4545 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1];
4546 /* for all motion vector read MVDATA and motion compensate each block */
4550 for (i = 0; i < 4; i++) {
4551 vc1_mc_4mv_luma(v, i, 0, 0);
4552 vc1_mc_4mv_luma(v, i, 1, 1);
4554 vc1_mc_4mv_chroma4(v, 0, 0, 0);
4555 vc1_mc_4mv_chroma4(v, 1, 1, 1);
4560 } else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) {
4562 for (i = 0; i < 4; i++) {
4565 val = ((mvbp >> (3 - i)) & 1);
4567 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4569 vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4570 vc1_mc_4mv_luma(v, j, dir, dir);
4571 vc1_mc_4mv_luma(v, j+1, dir, dir);
4574 vc1_mc_4mv_chroma4(v, 0, 0, 0);
4575 vc1_mc_4mv_chroma4(v, 1, 1, 1);
4576 } else if (bmvtype == BMV_TYPE_INTERPOLATED) {
4580 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4582 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4587 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4589 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4592 dir = bmvtype == BMV_TYPE_BACKWARD;
4599 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4600 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4604 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4605 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir2);
4608 for (i = 0; i < 2; i++) {
4609 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];
4610 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];
4611 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];
4612 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];
4615 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4616 vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4619 vc1_mc_4mv_luma(v, 0, dir, 0);
4620 vc1_mc_4mv_luma(v, 1, dir, 0);
4621 vc1_mc_4mv_luma(v, 2, dir2, 0);
4622 vc1_mc_4mv_luma(v, 3, dir2, 0);
4623 vc1_mc_4mv_chroma4(v, dir, dir2, 0);
4625 dir = bmvtype == BMV_TYPE_BACKWARD;
4627 mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2];
4630 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4632 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4633 v->blk_mv_type[s->block_index[0]] = 1;
4634 v->blk_mv_type[s->block_index[1]] = 1;
4635 v->blk_mv_type[s->block_index[2]] = 1;
4636 v->blk_mv_type[s->block_index[3]] = 1;
4637 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4638 for (i = 0; i < 2; i++) {
4639 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];
4640 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];
4646 GET_MQUANT(); // p. 227
4647 s->current_picture.qscale_table[mb_pos] = mquant;
4648 if (!v->ttmbf && cbp)
4649 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4650 for (i = 0; i < 6; i++) {
4651 s->dc_val[0][s->block_index[i]] = 0;
4653 val = ((cbp >> (5 - i)) & 1);
4655 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4657 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
4659 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4660 first_block, s->dest[dst_idx] + off,
4661 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
4662 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
4663 block_cbp |= pat << (i << 2);
4664 if (!v->ttmbf && ttmb < 8)
4672 for (i = 0; i < 6; i++) {
4673 v->mb_type[0][s->block_index[i]] = 0;
4674 s->dc_val[0][s->block_index[i]] = 0;
4676 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
4677 s->current_picture.qscale_table[mb_pos] = 0;
4678 v->blk_mv_type[s->block_index[0]] = 0;
4679 v->blk_mv_type[s->block_index[1]] = 0;
4680 v->blk_mv_type[s->block_index[2]] = 0;
4681 v->blk_mv_type[s->block_index[3]] = 0;
4684 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4685 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4686 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4688 dir = bmvtype == BMV_TYPE_BACKWARD;
4689 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4694 for (i = 0; i < 2; i++) {
4695 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];
4696 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];
4697 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];
4698 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];
4701 v->blk_mv_type[s->block_index[0]] = 1;
4702 v->blk_mv_type[s->block_index[1]] = 1;
4703 v->blk_mv_type[s->block_index[2]] = 1;
4704 v->blk_mv_type[s->block_index[3]] = 1;
4705 vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4706 for (i = 0; i < 2; i++) {
4707 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];
4708 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];
4715 if (direct || bmvtype == BMV_TYPE_INTERPOLATED) {
4720 if (s->mb_x == s->mb_width - 1)
4721 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4722 v->cbp[s->mb_x] = block_cbp;
4723 v->ttblk[s->mb_x] = block_tt;
4727 /** Decode blocks of I-frame
4729 static void vc1_decode_i_blocks(VC1Context *v)
4732 MpegEncContext *s = &v->s;
4737 /* select codingmode used for VLC tables selection */
4738 switch (v->y_ac_table_index) {
4740 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4743 v->codingset = CS_HIGH_MOT_INTRA;
4746 v->codingset = CS_MID_RATE_INTRA;
4750 switch (v->c_ac_table_index) {
4752 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4755 v->codingset2 = CS_HIGH_MOT_INTER;
4758 v->codingset2 = CS_MID_RATE_INTER;
4762 /* Set DC scale - y and c use the same */
4763 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4764 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4767 s->mb_x = s->mb_y = 0;
4769 s->first_slice_line = 1;
4770 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4772 init_block_index(v);
4773 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4775 ff_update_block_index(s);
4776 dst[0] = s->dest[0];
4777 dst[1] = dst[0] + 8;
4778 dst[2] = s->dest[0] + s->linesize * 8;
4779 dst[3] = dst[2] + 8;
4780 dst[4] = s->dest[1];
4781 dst[5] = s->dest[2];
4782 s->dsp.clear_blocks(s->block[0]);
4783 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4784 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4785 s->current_picture.qscale_table[mb_pos] = v->pq;
4786 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4787 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4789 // do actual MB decoding and displaying
4790 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4791 v->s.ac_pred = get_bits1(&v->s.gb);
4793 for (k = 0; k < 6; k++) {
4794 val = ((cbp >> (5 - k)) & 1);
4797 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4801 cbp |= val << (5 - k);
4803 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4805 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4807 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4808 if (v->pq >= 9 && v->overlap) {
4810 for (j = 0; j < 64; j++)
4811 s->block[k][j] <<= 1;
4812 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4815 for (j = 0; j < 64; j++)
4816 s->block[k][j] = (s->block[k][j] - 64) << 1;
4817 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4821 if (v->pq >= 9 && v->overlap) {
4823 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4824 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4825 if (!(s->flags & CODEC_FLAG_GRAY)) {
4826 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4827 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4830 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4831 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4832 if (!s->first_slice_line) {
4833 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4834 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4835 if (!(s->flags & CODEC_FLAG_GRAY)) {
4836 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4837 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4840 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4841 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4843 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4845 if (get_bits_count(&s->gb) > v->bits) {
4846 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4847 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4848 get_bits_count(&s->gb), v->bits);
4852 if (!v->s.loop_filter)
4853 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4855 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4857 s->first_slice_line = 0;
4859 if (v->s.loop_filter)
4860 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4862 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4863 * profile, these only differ are when decoding MSS2 rectangles. */
4864 ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4867 /** Decode blocks of I-frame for advanced profile
4869 static void vc1_decode_i_blocks_adv(VC1Context *v)
4872 MpegEncContext *s = &v->s;
4878 GetBitContext *gb = &s->gb;
4880 /* select codingmode used for VLC tables selection */
4881 switch (v->y_ac_table_index) {
4883 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4886 v->codingset = CS_HIGH_MOT_INTRA;
4889 v->codingset = CS_MID_RATE_INTRA;
4893 switch (v->c_ac_table_index) {
4895 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4898 v->codingset2 = CS_HIGH_MOT_INTER;
4901 v->codingset2 = CS_MID_RATE_INTER;
4906 s->mb_x = s->mb_y = 0;
4908 s->first_slice_line = 1;
4909 s->mb_y = s->start_mb_y;
4910 if (s->start_mb_y) {
4912 init_block_index(v);
4913 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4914 (1 + s->b8_stride) * sizeof(*s->coded_block));
4916 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4918 init_block_index(v);
4919 for (;s->mb_x < s->mb_width; s->mb_x++) {
4920 int16_t (*block)[64] = v->block[v->cur_blk_idx];
4921 ff_update_block_index(s);
4922 s->dsp.clear_blocks(block[0]);
4923 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4924 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4925 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4926 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4928 // do actual MB decoding and displaying
4929 if (v->fieldtx_is_raw)
4930 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4931 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4932 if ( v->acpred_is_raw)
4933 v->s.ac_pred = get_bits1(&v->s.gb);
4935 v->s.ac_pred = v->acpred_plane[mb_pos];
4937 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4938 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4942 s->current_picture.qscale_table[mb_pos] = mquant;
4943 /* Set DC scale - y and c use the same */
4944 s->y_dc_scale = s->y_dc_scale_table[mquant];
4945 s->c_dc_scale = s->c_dc_scale_table[mquant];
4947 for (k = 0; k < 6; k++) {
4948 val = ((cbp >> (5 - k)) & 1);
4951 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4955 cbp |= val << (5 - k);
4957 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4958 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4960 vc1_decode_i_block_adv(v, block[k], k, val,
4961 (k < 4) ? v->codingset : v->codingset2, mquant);
4963 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4965 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4968 vc1_smooth_overlap_filter_iblk(v);
4969 vc1_put_signed_blocks_clamped(v);
4970 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4972 if (get_bits_count(&s->gb) > v->bits) {
4973 // TODO: may need modification to handle slice coding
4974 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4975 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4976 get_bits_count(&s->gb), v->bits);
4980 if (!v->s.loop_filter)
4981 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4983 ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4984 s->first_slice_line = 0;
4987 /* raw bottom MB row */
4989 init_block_index(v);
4991 for (;s->mb_x < s->mb_width; s->mb_x++) {
4992 ff_update_block_index(s);
4993 vc1_put_signed_blocks_clamped(v);
4994 if (v->s.loop_filter)
4995 vc1_loop_filter_iblk_delayed(v, v->pq);
4997 if (v->s.loop_filter)
4998 ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4999 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5000 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5003 static void vc1_decode_p_blocks(VC1Context *v)
5005 MpegEncContext *s = &v->s;
5006 int apply_loop_filter;
5008 /* select codingmode used for VLC tables selection */
5009 switch (v->c_ac_table_index) {
5011 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5014 v->codingset = CS_HIGH_MOT_INTRA;
5017 v->codingset = CS_MID_RATE_INTRA;
5021 switch (v->c_ac_table_index) {
5023 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5026 v->codingset2 = CS_HIGH_MOT_INTER;
5029 v->codingset2 = CS_MID_RATE_INTER;
5033 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY) &&
5034 v->fcm == PROGRESSIVE;
5035 s->first_slice_line = 1;
5036 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
5037 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5039 init_block_index(v);
5040 for (; s->mb_x < s->mb_width; s->mb_x++) {
5041 ff_update_block_index(s);
5043 if (v->fcm == ILACE_FIELD)
5044 vc1_decode_p_mb_intfi(v);
5045 else if (v->fcm == ILACE_FRAME)
5046 vc1_decode_p_mb_intfr(v);
5047 else vc1_decode_p_mb(v);
5048 if (s->mb_y != s->start_mb_y && apply_loop_filter)
5049 vc1_apply_p_loop_filter(v);
5050 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5051 // TODO: may need modification to handle slice coding
5052 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5053 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5054 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5058 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
5059 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
5060 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
5061 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
5062 if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5063 s->first_slice_line = 0;
5065 if (apply_loop_filter) {
5067 init_block_index(v);
5068 for (; s->mb_x < s->mb_width; s->mb_x++) {
5069 ff_update_block_index(s);
5070 vc1_apply_p_loop_filter(v);
5073 if (s->end_mb_y >= s->start_mb_y)
5074 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5075 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5076 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5079 static void vc1_decode_b_blocks(VC1Context *v)
5081 MpegEncContext *s = &v->s;
5083 /* select codingmode used for VLC tables selection */
5084 switch (v->c_ac_table_index) {
5086 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5089 v->codingset = CS_HIGH_MOT_INTRA;
5092 v->codingset = CS_MID_RATE_INTRA;
5096 switch (v->c_ac_table_index) {
5098 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5101 v->codingset2 = CS_HIGH_MOT_INTER;
5104 v->codingset2 = CS_MID_RATE_INTER;
5108 s->first_slice_line = 1;
5109 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5111 init_block_index(v);
5112 for (; s->mb_x < s->mb_width; s->mb_x++) {
5113 ff_update_block_index(s);
5115 if (v->fcm == ILACE_FIELD)
5116 vc1_decode_b_mb_intfi(v);
5117 else if (v->fcm == ILACE_FRAME)
5118 vc1_decode_b_mb_intfr(v);
5121 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5122 // TODO: may need modification to handle slice coding
5123 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5124 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5125 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5128 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
5130 if (!v->s.loop_filter)
5131 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5133 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5134 s->first_slice_line = 0;
5136 if (v->s.loop_filter)
5137 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5138 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5139 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5142 static void vc1_decode_skip_blocks(VC1Context *v)
5144 MpegEncContext *s = &v->s;
5146 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
5147 s->first_slice_line = 1;
5148 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5150 init_block_index(v);
5151 ff_update_block_index(s);
5152 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
5153 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5154 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5155 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5156 s->first_slice_line = 0;
5158 s->pict_type = AV_PICTURE_TYPE_P;
5161 void ff_vc1_decode_blocks(VC1Context *v)
5164 v->s.esc3_level_length = 0;
5166 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
5169 v->left_blk_idx = -1;
5170 v->topleft_blk_idx = 1;
5172 switch (v->s.pict_type) {
5173 case AV_PICTURE_TYPE_I:
5174 if (v->profile == PROFILE_ADVANCED)
5175 vc1_decode_i_blocks_adv(v);
5177 vc1_decode_i_blocks(v);
5179 case AV_PICTURE_TYPE_P:
5180 if (v->p_frame_skipped)
5181 vc1_decode_skip_blocks(v);
5183 vc1_decode_p_blocks(v);
5185 case AV_PICTURE_TYPE_B:
5187 if (v->profile == PROFILE_ADVANCED)
5188 vc1_decode_i_blocks_adv(v);
5190 vc1_decode_i_blocks(v);
5192 vc1_decode_b_blocks(v);
5198 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5202 * Transform coefficients for both sprites in 16.16 fixed point format,
5203 * in the order they appear in the bitstream:
5205 * rotation 1 (unused)
5207 * rotation 2 (unused)
5214 int effect_type, effect_flag;
5215 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
5216 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
5219 static inline int get_fp_val(GetBitContext* gb)
5221 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
5224 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
5228 switch (get_bits(gb, 2)) {
5231 c[2] = get_fp_val(gb);
5235 c[0] = c[4] = get_fp_val(gb);
5236 c[2] = get_fp_val(gb);
5239 c[0] = get_fp_val(gb);
5240 c[2] = get_fp_val(gb);
5241 c[4] = get_fp_val(gb);
5244 c[0] = get_fp_val(gb);
5245 c[1] = get_fp_val(gb);
5246 c[2] = get_fp_val(gb);
5247 c[3] = get_fp_val(gb);
5248 c[4] = get_fp_val(gb);
5251 c[5] = get_fp_val(gb);
5253 c[6] = get_fp_val(gb);
5258 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
5260 AVCodecContext *avctx = v->s.avctx;
5263 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5264 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
5265 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
5266 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
5267 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
5268 for (i = 0; i < 7; i++)
5269 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
5270 sd->coefs[sprite][i] / (1<<16),
5271 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
5272 av_log(avctx, AV_LOG_DEBUG, "\n");
5276 if (sd->effect_type = get_bits_long(gb, 30)) {
5277 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
5279 vc1_sprite_parse_transform(gb, sd->effect_params1);
5282 vc1_sprite_parse_transform(gb, sd->effect_params1);
5283 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
5286 for (i = 0; i < sd->effect_pcount1; i++)
5287 sd->effect_params1[i] = get_fp_val(gb);
5289 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
5290 // effect 13 is simple alpha blending and matches the opacity above
5291 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
5292 for (i = 0; i < sd->effect_pcount1; i++)
5293 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5294 sd->effect_params1[i] / (1 << 16),
5295 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
5296 av_log(avctx, AV_LOG_DEBUG, "\n");
5299 sd->effect_pcount2 = get_bits(gb, 16);
5300 if (sd->effect_pcount2 > 10) {
5301 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
5303 } else if (sd->effect_pcount2) {
5305 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
5306 while (++i < sd->effect_pcount2) {
5307 sd->effect_params2[i] = get_fp_val(gb);
5308 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5309 sd->effect_params2[i] / (1 << 16),
5310 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
5312 av_log(avctx, AV_LOG_DEBUG, "\n");
5315 if (sd->effect_flag = get_bits1(gb))
5316 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
5318 if (get_bits_count(gb) >= gb->size_in_bits +
5319 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
5320 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
5321 if (get_bits_count(gb) < gb->size_in_bits - 8)
5322 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
5325 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
5327 int i, plane, row, sprite;
5328 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
5329 uint8_t* src_h[2][2];
5330 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
5332 MpegEncContext *s = &v->s;
5334 for (i = 0; i < 2; i++) {
5335 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
5336 xadv[i] = sd->coefs[i][0];
5337 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
5338 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
5340 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
5341 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
5343 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
5345 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
5346 int width = v->output_width>>!!plane;
5348 for (row = 0; row < v->output_height>>!!plane; row++) {
5349 uint8_t *dst = v->sprite_output_frame.data[plane] +
5350 v->sprite_output_frame.linesize[plane] * row;
5352 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5353 uint8_t *iplane = s->current_picture.f.data[plane];
5354 int iline = s->current_picture.f.linesize[plane];
5355 int ycoord = yoff[sprite] + yadv[sprite] * row;
5356 int yline = ycoord >> 16;
5358 ysub[sprite] = ycoord & 0xFFFF;
5360 iplane = s->last_picture.f.data[plane];
5361 iline = s->last_picture.f.linesize[plane];
5363 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
5364 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
5365 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
5367 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
5369 if (sr_cache[sprite][0] != yline) {
5370 if (sr_cache[sprite][1] == yline) {
5371 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
5372 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
5374 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
5375 sr_cache[sprite][0] = yline;
5378 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
5379 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
5380 iplane + next_line, xoff[sprite],
5381 xadv[sprite], width);
5382 sr_cache[sprite][1] = yline + 1;
5384 src_h[sprite][0] = v->sr_rows[sprite][0];
5385 src_h[sprite][1] = v->sr_rows[sprite][1];
5389 if (!v->two_sprites) {
5391 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
5393 memcpy(dst, src_h[0][0], width);
5396 if (ysub[0] && ysub[1]) {
5397 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5398 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5399 } else if (ysub[0]) {
5400 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5401 src_h[1][0], alpha, width);
5402 } else if (ysub[1]) {
5403 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5404 src_h[0][0], (1<<16)-1-alpha, width);
5406 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5412 for (i = 0; i < 2; i++) {
5422 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5424 MpegEncContext *s = &v->s;
5425 AVCodecContext *avctx = s->avctx;
5428 vc1_parse_sprites(v, gb, &sd);
5430 if (!s->current_picture.f.data[0]) {
5431 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5435 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5436 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5440 av_frame_unref(&v->sprite_output_frame);
5441 if (ff_get_buffer(avctx, &v->sprite_output_frame, 0) < 0) {
5442 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5446 vc1_draw_sprites(v, &sd);
5451 static void vc1_sprite_flush(AVCodecContext *avctx)
5453 VC1Context *v = avctx->priv_data;
5454 MpegEncContext *s = &v->s;
5455 AVFrame *f = &s->current_picture.f;
5458 /* Windows Media Image codecs have a convergence interval of two keyframes.
5459 Since we can't enforce it, clear to black the missing sprite. This is
5460 wrong but it looks better than doing nothing. */
5463 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5464 for (i = 0; i < v->sprite_height>>!!plane; i++)
5465 memset(f->data[plane] + i * f->linesize[plane],
5466 plane ? 128 : 0, f->linesize[plane]);
5471 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5473 MpegEncContext *s = &v->s;
5476 /* Allocate mb bitplanes */
5477 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5478 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5479 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5480 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5481 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5482 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5484 v->n_allocated_blks = s->mb_width + 2;
5485 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5486 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5487 v->cbp = v->cbp_base + s->mb_stride;
5488 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5489 v->ttblk = v->ttblk_base + s->mb_stride;
5490 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5491 v->is_intra = v->is_intra_base + s->mb_stride;
5492 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5493 v->luma_mv = v->luma_mv_base + s->mb_stride;
5495 /* allocate block type info in that way so it could be used with s->block_index[] */
5496 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5497 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5498 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5499 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5501 /* allocate memory to store block level MV info */
5502 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5503 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5504 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5505 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5506 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5507 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5508 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5509 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);
5511 /* Init coded blocks info */
5512 if (v->profile == PROFILE_ADVANCED) {
5513 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5515 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5519 ff_intrax8_common_init(&v->x8,s);
5521 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5522 for (i = 0; i < 4; i++)
5523 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5526 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5527 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5534 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5537 for (i = 0; i < 64; i++) {
5538 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5539 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5540 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5541 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5542 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5543 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5549 /** Initialize a VC1/WMV3 decoder
5550 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5551 * @todo TODO: Decypher remaining bits in extra_data
5553 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5555 VC1Context *v = avctx->priv_data;
5556 MpegEncContext *s = &v->s;
5559 /* save the container output size for WMImage */
5560 v->output_width = avctx->width;
5561 v->output_height = avctx->height;
5563 if (!avctx->extradata_size || !avctx->extradata)
5565 if (!(avctx->flags & CODEC_FLAG_GRAY))
5566 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5568 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5569 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5571 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5572 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5574 if (ff_vc1_init_common(v) < 0)
5576 ff_h264chroma_init(&v->h264chroma, 8);
5577 ff_vc1dsp_init(&v->vc1dsp);
5579 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5582 // looks like WMV3 has a sequence header stored in the extradata
5583 // advanced sequence header may be before the first frame
5584 // the last byte of the extradata is a version number, 1 for the
5585 // samples we can decode
5587 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5589 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5592 count = avctx->extradata_size*8 - get_bits_count(&gb);
5594 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5595 count, get_bits(&gb, count));
5596 } else if (count < 0) {
5597 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5599 } else { // VC1/WVC1/WVP2
5600 const uint8_t *start = avctx->extradata;
5601 uint8_t *end = avctx->extradata + avctx->extradata_size;
5602 const uint8_t *next;
5603 int size, buf2_size;
5604 uint8_t *buf2 = NULL;
5605 int seq_initialized = 0, ep_initialized = 0;
5607 if (avctx->extradata_size < 16) {
5608 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5612 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5613 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5615 for (; next < end; start = next) {
5616 next = find_next_marker(start + 4, end);
5617 size = next - start - 4;
5620 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5621 init_get_bits(&gb, buf2, buf2_size * 8);
5622 switch (AV_RB32(start)) {
5623 case VC1_CODE_SEQHDR:
5624 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5628 seq_initialized = 1;
5630 case VC1_CODE_ENTRYPOINT:
5631 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5640 if (!seq_initialized || !ep_initialized) {
5641 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5644 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5647 avctx->profile = v->profile;
5648 if (v->profile == PROFILE_ADVANCED)
5649 avctx->level = v->level;
5651 avctx->has_b_frames = !!avctx->max_b_frames;
5653 s->mb_width = (avctx->coded_width + 15) >> 4;
5654 s->mb_height = (avctx->coded_height + 15) >> 4;
5656 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5657 ff_vc1_init_transposed_scantables(v);
5659 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5664 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5665 v->sprite_width = avctx->coded_width;
5666 v->sprite_height = avctx->coded_height;
5668 avctx->coded_width = avctx->width = v->output_width;
5669 avctx->coded_height = avctx->height = v->output_height;
5671 // prevent 16.16 overflows
5672 if (v->sprite_width > 1 << 14 ||
5673 v->sprite_height > 1 << 14 ||
5674 v->output_width > 1 << 14 ||
5675 v->output_height > 1 << 14) return -1;
5680 /** Close a VC1/WMV3 decoder
5681 * @warning Initial try at using MpegEncContext stuff
5683 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5685 VC1Context *v = avctx->priv_data;
5688 av_frame_unref(&v->sprite_output_frame);
5690 for (i = 0; i < 4; i++)
5691 av_freep(&v->sr_rows[i >> 1][i & 1]);
5692 av_freep(&v->hrd_rate);
5693 av_freep(&v->hrd_buffer);
5694 ff_MPV_common_end(&v->s);
5695 av_freep(&v->mv_type_mb_plane);
5696 av_freep(&v->direct_mb_plane);
5697 av_freep(&v->forward_mb_plane);
5698 av_freep(&v->fieldtx_plane);
5699 av_freep(&v->acpred_plane);
5700 av_freep(&v->over_flags_plane);
5701 av_freep(&v->mb_type_base);
5702 av_freep(&v->blk_mv_type_base);
5703 av_freep(&v->mv_f_base);
5704 av_freep(&v->mv_f_next_base);
5705 av_freep(&v->block);
5706 av_freep(&v->cbp_base);
5707 av_freep(&v->ttblk_base);
5708 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5709 av_freep(&v->luma_mv_base);
5710 ff_intrax8_common_end(&v->x8);
5715 /** Decode a VC1/WMV3 frame
5716 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5718 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5719 int *got_frame, AVPacket *avpkt)
5721 const uint8_t *buf = avpkt->data;
5722 int buf_size = avpkt->size, n_slices = 0, i, ret;
5723 VC1Context *v = avctx->priv_data;
5724 MpegEncContext *s = &v->s;
5725 AVFrame *pict = data;
5726 uint8_t *buf2 = NULL;
5727 const uint8_t *buf_start = buf;
5728 int mb_height, n_slices1;
5733 } *slices = NULL, *tmp;
5735 /* no supplementary picture */
5736 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5737 /* special case for last picture */
5738 if (s->low_delay == 0 && s->next_picture_ptr) {
5739 if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
5741 s->next_picture_ptr = NULL;
5749 //for advanced profile we may need to parse and unescape data
5750 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5752 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5754 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5755 const uint8_t *start, *end, *next;
5759 for (start = buf, end = buf + buf_size; next < end; start = next) {
5760 next = find_next_marker(start + 4, end);
5761 size = next - start - 4;
5762 if (size <= 0) continue;
5763 switch (AV_RB32(start)) {
5764 case VC1_CODE_FRAME:
5767 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5769 case VC1_CODE_FIELD: {
5771 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5775 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5776 if (!slices[n_slices].buf)
5778 buf_size3 = vc1_unescape_buffer(start + 4, size,
5779 slices[n_slices].buf);
5780 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5782 /* assuming that the field marker is at the exact middle,
5783 hope it's correct */
5784 slices[n_slices].mby_start = s->mb_height >> 1;
5785 n_slices1 = n_slices - 1; // index of the last slice of the first field
5789 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5790 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5791 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5792 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5794 case VC1_CODE_SLICE: {
5796 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5800 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5801 if (!slices[n_slices].buf)
5803 buf_size3 = vc1_unescape_buffer(start + 4, size,
5804 slices[n_slices].buf);
5805 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5807 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5813 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5814 const uint8_t *divider;
5817 divider = find_next_marker(buf, buf + buf_size);
5818 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5819 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5821 } else { // found field marker, unescape second field
5822 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5826 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5827 if (!slices[n_slices].buf)
5829 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5830 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5832 slices[n_slices].mby_start = s->mb_height >> 1;
5833 n_slices1 = n_slices - 1;
5836 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5838 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5840 init_get_bits(&s->gb, buf2, buf_size2*8);
5842 init_get_bits(&s->gb, buf, buf_size*8);
5844 if (v->res_sprite) {
5845 v->new_sprite = !get_bits1(&s->gb);
5846 v->two_sprites = get_bits1(&s->gb);
5847 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5848 we're using the sprite compositor. These are intentionally kept separate
5849 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5850 the vc1 one for WVP2 */
5851 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5852 if (v->new_sprite) {
5853 // switch AVCodecContext parameters to those of the sprites
5854 avctx->width = avctx->coded_width = v->sprite_width;
5855 avctx->height = avctx->coded_height = v->sprite_height;
5862 if (s->context_initialized &&
5863 (s->width != avctx->coded_width ||
5864 s->height != avctx->coded_height)) {
5865 ff_vc1_decode_end(avctx);
5868 if (!s->context_initialized) {
5869 if (ff_msmpeg4_decode_init(avctx) < 0 || ff_vc1_decode_init_alloc_tables(v) < 0)
5872 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5874 if (v->profile == PROFILE_ADVANCED) {
5875 s->h_edge_pos = avctx->coded_width;
5876 s->v_edge_pos = avctx->coded_height;
5880 /* We need to set current_picture_ptr before reading the header,
5881 * otherwise we cannot store anything in there. */
5882 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5883 int i = ff_find_unused_picture(s, 0);
5886 s->current_picture_ptr = &s->picture[i];
5889 // do parse frame header
5890 v->pic_header_flag = 0;
5891 v->first_pic_header_flag = 1;
5892 if (v->profile < PROFILE_ADVANCED) {
5893 if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5897 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5901 v->first_pic_header_flag = 0;
5903 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5904 && s->pict_type != AV_PICTURE_TYPE_I) {
5905 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5909 // process pulldown flags
5910 s->current_picture_ptr->f.repeat_pict = 0;
5911 // Pulldown flags are only valid when 'broadcast' has been set.
5912 // So ticks_per_frame will be 2
5915 s->current_picture_ptr->f.repeat_pict = 1;
5916 } else if (v->rptfrm) {
5918 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5921 // for skipping the frame
5922 s->current_picture.f.pict_type = s->pict_type;
5923 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5925 /* skip B-frames if we don't have reference frames */
5926 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
5929 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5930 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5931 avctx->skip_frame >= AVDISCARD_ALL) {
5935 if (s->next_p_frame_damaged) {
5936 if (s->pict_type == AV_PICTURE_TYPE_B)
5939 s->next_p_frame_damaged = 0;
5942 if (ff_MPV_frame_start(s, avctx) < 0) {
5946 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5947 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5949 if (avctx->hwaccel) {
5950 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
5952 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5954 if (avctx->hwaccel->end_frame(avctx) < 0)
5957 ff_mpeg_er_frame_start(s);
5959 v->bits = buf_size * 8;
5960 v->end_mb_x = s->mb_width;
5961 if (v->field_mode) {
5962 s->current_picture.f.linesize[0] <<= 1;
5963 s->current_picture.f.linesize[1] <<= 1;
5964 s->current_picture.f.linesize[2] <<= 1;
5966 s->uvlinesize <<= 1;
5968 mb_height = s->mb_height >> v->field_mode;
5969 for (i = 0; i <= n_slices; i++) {
5970 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5971 if (v->field_mode <= 0) {
5972 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
5973 "picture boundary (%d >= %d)\n", i,
5974 slices[i - 1].mby_start, mb_height);
5977 v->second_field = 1;
5978 v->blocks_off = s->mb_width * s->mb_height << 1;
5979 v->mb_off = s->mb_stride * s->mb_height >> 1;
5981 v->second_field = 0;
5986 v->pic_header_flag = 0;
5987 if (v->field_mode && i == n_slices1 + 2) {
5988 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5989 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
5992 } else if (get_bits1(&s->gb)) {
5993 v->pic_header_flag = 1;
5994 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5995 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
6000 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
6001 if (!v->field_mode || v->second_field)
6002 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6004 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6005 ff_vc1_decode_blocks(v);
6007 s->gb = slices[i].gb;
6009 if (v->field_mode) {
6010 v->second_field = 0;
6011 s->current_picture.f.linesize[0] >>= 1;
6012 s->current_picture.f.linesize[1] >>= 1;
6013 s->current_picture.f.linesize[2] >>= 1;
6015 s->uvlinesize >>= 1;
6016 if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
6017 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
6018 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
6021 av_dlog(s->avctx, "Consumed %i/%i bits\n",
6022 get_bits_count(&s->gb), s->gb.size_in_bits);
6023 // if (get_bits_count(&s->gb) > buf_size * 8)
6026 ff_er_frame_end(&s->er);
6029 ff_MPV_frame_end(s);
6031 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
6033 avctx->width = avctx->coded_width = v->output_width;
6034 avctx->height = avctx->coded_height = v->output_height;
6035 if (avctx->skip_frame >= AVDISCARD_NONREF)
6037 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
6038 if (vc1_decode_sprites(v, &s->gb))
6041 if ((ret = av_frame_ref(pict, &v->sprite_output_frame)) < 0)
6045 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
6046 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
6048 ff_print_debug_info(s, s->current_picture_ptr);
6049 } else if (s->last_picture_ptr != NULL) {
6050 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
6052 ff_print_debug_info(s, s->last_picture_ptr);
6054 if (s->last_picture_ptr || s->low_delay) {
6061 for (i = 0; i < n_slices; i++)
6062 av_free(slices[i].buf);
6068 for (i = 0; i < n_slices; i++)
6069 av_free(slices[i].buf);
6075 static const AVProfile profiles[] = {
6076 { FF_PROFILE_VC1_SIMPLE, "Simple" },
6077 { FF_PROFILE_VC1_MAIN, "Main" },
6078 { FF_PROFILE_VC1_COMPLEX, "Complex" },
6079 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
6080 { FF_PROFILE_UNKNOWN },
6083 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
6085 AV_PIX_FMT_DXVA2_VLD,
6088 AV_PIX_FMT_VAAPI_VLD,
6097 AVCodec ff_vc1_decoder = {
6099 .type = AVMEDIA_TYPE_VIDEO,
6100 .id = AV_CODEC_ID_VC1,
6101 .priv_data_size = sizeof(VC1Context),
6102 .init = vc1_decode_init,
6103 .close = ff_vc1_decode_end,
6104 .decode = vc1_decode_frame,
6105 .flush = ff_mpeg_flush,
6106 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6107 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
6108 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6109 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6112 #if CONFIG_WMV3_DECODER
6113 AVCodec ff_wmv3_decoder = {
6115 .type = AVMEDIA_TYPE_VIDEO,
6116 .id = AV_CODEC_ID_WMV3,
6117 .priv_data_size = sizeof(VC1Context),
6118 .init = vc1_decode_init,
6119 .close = ff_vc1_decode_end,
6120 .decode = vc1_decode_frame,
6121 .flush = ff_mpeg_flush,
6122 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6123 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
6124 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6125 .profiles = NULL_IF_CONFIG_SMALL(profiles)
6129 #if CONFIG_WMV3IMAGE_DECODER
6130 AVCodec ff_wmv3image_decoder = {
6131 .name = "wmv3image",
6132 .type = AVMEDIA_TYPE_VIDEO,
6133 .id = AV_CODEC_ID_WMV3IMAGE,
6134 .priv_data_size = sizeof(VC1Context),
6135 .init = vc1_decode_init,
6136 .close = ff_vc1_decode_end,
6137 .decode = vc1_decode_frame,
6138 .capabilities = CODEC_CAP_DR1,
6139 .flush = vc1_sprite_flush,
6140 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
6141 .pix_fmts = ff_pixfmt_list_420
6145 #if CONFIG_VC1IMAGE_DECODER
6146 AVCodec ff_vc1image_decoder = {
6148 .type = AVMEDIA_TYPE_VIDEO,
6149 .id = AV_CODEC_ID_VC1IMAGE,
6150 .priv_data_size = sizeof(VC1Context),
6151 .init = vc1_decode_init,
6152 .close = ff_vc1_decode_end,
6153 .decode = vc1_decode_frame,
6154 .capabilities = CODEC_CAP_DR1,
6155 .flush = vc1_sprite_flush,
6156 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
6157 .pix_fmts = ff_pixfmt_list_420