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"
41 #include "vdpau_internal.h"
46 #define MB_INTRA_VLC_BITS 9
50 // offset tables for interlaced picture MVDATA decoding
51 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
52 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
54 /***********************************************************************/
56 * @name VC-1 Bitplane decoding
74 /** @} */ //imode defines
77 /** @} */ //Bitplane group
79 static void vc1_put_signed_blocks_clamped(VC1Context *v)
81 MpegEncContext *s = &v->s;
82 int topleft_mb_pos, top_mb_pos;
83 int stride_y, fieldtx;
86 /* The put pixels loop is always one MB row behind the decoding loop,
87 * because we can only put pixels when overlap filtering is done, and
88 * for filtering of the bottom edge of a MB, we need the next MB row
90 * Within the row, the put pixels loop is also one MB col behind the
91 * decoding loop. The reason for this is again, because for filtering
92 * of the right MB edge, we need the next MB present. */
93 if (!s->first_slice_line) {
95 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
96 fieldtx = v->fieldtx_plane[topleft_mb_pos];
97 stride_y = s->linesize << fieldtx;
98 v_dist = (16 - fieldtx) >> (fieldtx == 0);
99 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
100 s->dest[0] - 16 * s->linesize - 16,
102 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
103 s->dest[0] - 16 * s->linesize - 8,
105 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
106 s->dest[0] - v_dist * s->linesize - 16,
108 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
109 s->dest[0] - v_dist * s->linesize - 8,
111 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
112 s->dest[1] - 8 * s->uvlinesize - 8,
114 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
115 s->dest[2] - 8 * s->uvlinesize - 8,
118 if (s->mb_x == s->mb_width - 1) {
119 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
120 fieldtx = v->fieldtx_plane[top_mb_pos];
121 stride_y = s->linesize << fieldtx;
122 v_dist = fieldtx ? 15 : 8;
123 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
124 s->dest[0] - 16 * s->linesize,
126 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
127 s->dest[0] - 16 * s->linesize + 8,
129 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
130 s->dest[0] - v_dist * s->linesize,
132 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
133 s->dest[0] - v_dist * s->linesize + 8,
135 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
136 s->dest[1] - 8 * s->uvlinesize,
138 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
139 s->dest[2] - 8 * s->uvlinesize,
144 #define inc_blk_idx(idx) do { \
146 if (idx >= v->n_allocated_blks) \
150 inc_blk_idx(v->topleft_blk_idx);
151 inc_blk_idx(v->top_blk_idx);
152 inc_blk_idx(v->left_blk_idx);
153 inc_blk_idx(v->cur_blk_idx);
156 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
158 MpegEncContext *s = &v->s;
160 if (!s->first_slice_line) {
161 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
163 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
164 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
165 for (j = 0; j < 2; j++) {
166 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
168 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
171 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
173 if (s->mb_y == s->end_mb_y - 1) {
175 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
176 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
177 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
179 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
183 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
185 MpegEncContext *s = &v->s;
188 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
189 * means it runs two rows/cols behind the decoding loop. */
190 if (!s->first_slice_line) {
192 if (s->mb_y >= s->start_mb_y + 2) {
193 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
196 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
197 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
198 for (j = 0; j < 2; j++) {
199 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
201 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
205 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
208 if (s->mb_x == s->mb_width - 1) {
209 if (s->mb_y >= s->start_mb_y + 2) {
210 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
213 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
214 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
215 for (j = 0; j < 2; j++) {
216 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
218 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
222 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
225 if (s->mb_y == s->end_mb_y) {
228 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
229 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
231 for (j = 0; j < 2; j++) {
232 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
237 if (s->mb_x == s->mb_width - 1) {
239 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
240 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
242 for (j = 0; j < 2; j++) {
243 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
251 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
253 MpegEncContext *s = &v->s;
256 if (v->condover == CONDOVER_NONE)
259 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
261 /* Within a MB, the horizontal overlap always runs before the vertical.
262 * To accomplish that, we run the H on left and internal borders of the
263 * currently decoded MB. Then, we wait for the next overlap iteration
264 * to do H overlap on the right edge of this MB, before moving over and
265 * running the V overlap. Therefore, the V overlap makes us trail by one
266 * MB col and the H overlap filter makes us trail by one MB row. This
267 * is reflected in the time at which we run the put_pixels loop. */
268 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
269 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
270 v->over_flags_plane[mb_pos - 1])) {
271 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
272 v->block[v->cur_blk_idx][0]);
273 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
274 v->block[v->cur_blk_idx][2]);
275 if (!(s->flags & CODEC_FLAG_GRAY)) {
276 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
277 v->block[v->cur_blk_idx][4]);
278 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
279 v->block[v->cur_blk_idx][5]);
282 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
283 v->block[v->cur_blk_idx][1]);
284 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
285 v->block[v->cur_blk_idx][3]);
287 if (s->mb_x == s->mb_width - 1) {
288 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
289 v->over_flags_plane[mb_pos - s->mb_stride])) {
290 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
291 v->block[v->cur_blk_idx][0]);
292 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
293 v->block[v->cur_blk_idx][1]);
294 if (!(s->flags & CODEC_FLAG_GRAY)) {
295 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
296 v->block[v->cur_blk_idx][4]);
297 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
298 v->block[v->cur_blk_idx][5]);
301 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
302 v->block[v->cur_blk_idx][2]);
303 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
304 v->block[v->cur_blk_idx][3]);
307 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
308 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
309 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
310 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
311 v->block[v->left_blk_idx][0]);
312 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
313 v->block[v->left_blk_idx][1]);
314 if (!(s->flags & CODEC_FLAG_GRAY)) {
315 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
316 v->block[v->left_blk_idx][4]);
317 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
318 v->block[v->left_blk_idx][5]);
321 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
322 v->block[v->left_blk_idx][2]);
323 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
324 v->block[v->left_blk_idx][3]);
328 /** Do motion compensation over 1 macroblock
329 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
331 static void vc1_mc_1mv(VC1Context *v, int dir)
333 MpegEncContext *s = &v->s;
334 H264ChromaContext *h264chroma = &v->h264chroma;
335 uint8_t *srcY, *srcU, *srcV;
336 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
338 int v_edge_pos = s->v_edge_pos >> v->field_mode;
340 if ((!v->field_mode ||
341 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
342 !v->s.last_picture.f.data[0])
345 mx = s->mv[dir][0][0];
346 my = s->mv[dir][0][1];
348 // store motion vectors for further use in B frames
349 if (s->pict_type == AV_PICTURE_TYPE_P) {
350 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
351 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
354 uvmx = (mx + ((mx & 3) == 3)) >> 1;
355 uvmy = (my + ((my & 3) == 3)) >> 1;
356 v->luma_mv[s->mb_x][0] = uvmx;
357 v->luma_mv[s->mb_x][1] = uvmy;
360 v->cur_field_type != v->ref_field_type[dir]) {
361 my = my - 2 + 4 * v->cur_field_type;
362 uvmy = uvmy - 2 + 4 * v->cur_field_type;
365 // fastuvmc shall be ignored for interlaced frame picture
366 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
367 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
368 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
370 if (v->field_mode) { // interlaced field picture
372 if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type) {
373 srcY = s->current_picture.f.data[0];
374 srcU = s->current_picture.f.data[1];
375 srcV = s->current_picture.f.data[2];
377 srcY = s->last_picture.f.data[0];
378 srcU = s->last_picture.f.data[1];
379 srcV = s->last_picture.f.data[2];
382 srcY = s->next_picture.f.data[0];
383 srcU = s->next_picture.f.data[1];
384 srcV = s->next_picture.f.data[2];
388 srcY = s->last_picture.f.data[0];
389 srcU = s->last_picture.f.data[1];
390 srcV = s->last_picture.f.data[2];
392 srcY = s->next_picture.f.data[0];
393 srcU = s->next_picture.f.data[1];
394 srcV = s->next_picture.f.data[2];
398 src_x = s->mb_x * 16 + (mx >> 2);
399 src_y = s->mb_y * 16 + (my >> 2);
400 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
401 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
403 if (v->profile != PROFILE_ADVANCED) {
404 src_x = av_clip( src_x, -16, s->mb_width * 16);
405 src_y = av_clip( src_y, -16, s->mb_height * 16);
406 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
407 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
409 src_x = av_clip( src_x, -17, s->avctx->coded_width);
410 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
411 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
412 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
415 srcY += src_y * s->linesize + src_x;
416 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
417 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
419 if (v->field_mode && v->ref_field_type[dir]) {
420 srcY += s->current_picture_ptr->f.linesize[0];
421 srcU += s->current_picture_ptr->f.linesize[1];
422 srcV += s->current_picture_ptr->f.linesize[2];
425 /* for grayscale we should not try to read from unknown area */
426 if (s->flags & CODEC_FLAG_GRAY) {
427 srcU = s->edge_emu_buffer + 18 * s->linesize;
428 srcV = s->edge_emu_buffer + 18 * s->linesize;
431 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
432 || s->h_edge_pos < 22 || v_edge_pos < 22
433 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
434 || (unsigned)(src_y - 1) > v_edge_pos - (my&3) - 16 - 3) {
435 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
437 srcY -= s->mspel * (1 + s->linesize);
438 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
439 17 + s->mspel * 2, 17 + s->mspel * 2,
440 src_x - s->mspel, src_y - s->mspel,
441 s->h_edge_pos, v_edge_pos);
442 srcY = s->edge_emu_buffer;
443 s->vdsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
444 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
445 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
446 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
449 /* if we deal with range reduction we need to scale source blocks */
450 if (v->rangeredfrm) {
455 for (j = 0; j < 17 + s->mspel * 2; j++) {
456 for (i = 0; i < 17 + s->mspel * 2; i++)
457 src[i] = ((src[i] - 128) >> 1) + 128;
462 for (j = 0; j < 9; j++) {
463 for (i = 0; i < 9; i++) {
464 src[i] = ((src[i] - 128) >> 1) + 128;
465 src2[i] = ((src2[i] - 128) >> 1) + 128;
467 src += s->uvlinesize;
468 src2 += s->uvlinesize;
471 /* if we deal with intensity compensation we need to scale source blocks */
472 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
477 for (j = 0; j < 17 + s->mspel * 2; j++) {
478 for (i = 0; i < 17 + s->mspel * 2; i++)
479 src[i] = v->luty[src[i]];
484 for (j = 0; j < 9; j++) {
485 for (i = 0; i < 9; i++) {
486 src[i] = v->lutuv[src[i]];
487 src2[i] = v->lutuv[src2[i]];
489 src += s->uvlinesize;
490 src2 += s->uvlinesize;
493 srcY += s->mspel * (1 + s->linesize);
496 if (v->field_mode && v->cur_field_type) {
497 off = s->current_picture_ptr->f.linesize[0];
498 off_uv = s->current_picture_ptr->f.linesize[1];
504 dxy = ((my & 3) << 2) | (mx & 3);
505 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
506 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
507 srcY += s->linesize * 8;
508 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
509 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
510 } else { // hpel mc - always used for luma
511 dxy = (my & 2) | ((mx & 2) >> 1);
513 s->hdsp.put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
515 s->hdsp.put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
518 if (s->flags & CODEC_FLAG_GRAY) return;
519 /* Chroma MC always uses qpel bilinear */
520 uvmx = (uvmx & 3) << 1;
521 uvmy = (uvmy & 3) << 1;
523 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
524 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
526 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
527 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
531 static inline int median4(int a, int b, int c, int d)
534 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
535 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
537 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
538 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
542 /** Do motion compensation for 4-MV macroblock - luminance block
544 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
546 MpegEncContext *s = &v->s;
548 int dxy, mx, my, src_x, src_y;
550 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
551 int v_edge_pos = s->v_edge_pos >> v->field_mode;
553 if ((!v->field_mode ||
554 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
555 !v->s.last_picture.f.data[0])
558 mx = s->mv[dir][n][0];
559 my = s->mv[dir][n][1];
563 if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type)
564 srcY = s->current_picture.f.data[0];
566 srcY = s->last_picture.f.data[0];
568 srcY = s->last_picture.f.data[0];
570 srcY = s->next_picture.f.data[0];
573 if (v->cur_field_type != v->ref_field_type[dir])
574 my = my - 2 + 4 * v->cur_field_type;
577 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
578 int same_count = 0, opp_count = 0, k;
579 int chosen_mv[2][4][2], f;
581 for (k = 0; k < 4; k++) {
582 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
583 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
584 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
588 f = opp_count > same_count;
589 switch (f ? opp_count : same_count) {
591 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
592 chosen_mv[f][2][0], chosen_mv[f][3][0]);
593 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
594 chosen_mv[f][2][1], chosen_mv[f][3][1]);
597 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
598 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
601 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
602 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
605 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
606 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
607 for (k = 0; k < 4; k++)
608 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
611 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
613 int width = s->avctx->coded_width;
614 int height = s->avctx->coded_height >> 1;
615 qx = (s->mb_x * 16) + (mx >> 2);
616 qy = (s->mb_y * 8) + (my >> 3);
621 mx -= 4 * (qx - width);
624 else if (qy > height + 1)
625 my -= 8 * (qy - height - 1);
628 if ((v->fcm == ILACE_FRAME) && fieldmv)
629 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
631 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
632 if (v->field_mode && v->cur_field_type)
633 off += s->current_picture_ptr->f.linesize[0];
635 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
637 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
639 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
641 if (v->profile != PROFILE_ADVANCED) {
642 src_x = av_clip(src_x, -16, s->mb_width * 16);
643 src_y = av_clip(src_y, -16, s->mb_height * 16);
645 src_x = av_clip(src_x, -17, s->avctx->coded_width);
646 if (v->fcm == ILACE_FRAME) {
648 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
650 src_y = av_clip(src_y, -18, s->avctx->coded_height);
652 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
656 srcY += src_y * s->linesize + src_x;
657 if (v->field_mode && v->ref_field_type[dir])
658 srcY += s->current_picture_ptr->f.linesize[0];
660 if (fieldmv && !(src_y & 1))
662 if (fieldmv && (src_y & 1) && src_y < 4)
664 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
665 || s->h_edge_pos < 13 || v_edge_pos < 23
666 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
667 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
668 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
669 /* check emulate edge stride and offset */
670 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
671 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
672 src_x - s->mspel, src_y - (s->mspel << fieldmv),
673 s->h_edge_pos, v_edge_pos);
674 srcY = s->edge_emu_buffer;
675 /* if we deal with range reduction we need to scale source blocks */
676 if (v->rangeredfrm) {
681 for (j = 0; j < 9 + s->mspel * 2; j++) {
682 for (i = 0; i < 9 + s->mspel * 2; i++)
683 src[i] = ((src[i] - 128) >> 1) + 128;
684 src += s->linesize << fieldmv;
687 /* if we deal with intensity compensation we need to scale source blocks */
688 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
693 for (j = 0; j < 9 + s->mspel * 2; j++) {
694 for (i = 0; i < 9 + s->mspel * 2; i++)
695 src[i] = v->luty[src[i]];
696 src += s->linesize << fieldmv;
699 srcY += s->mspel * (1 + (s->linesize << fieldmv));
703 dxy = ((my & 3) << 2) | (mx & 3);
704 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
705 } else { // hpel mc - always used for luma
706 dxy = (my & 2) | ((mx & 2) >> 1);
708 s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
710 s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
714 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
717 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
719 idx = ((a[3] != flag) << 3)
720 | ((a[2] != flag) << 2)
721 | ((a[1] != flag) << 1)
724 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
725 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
727 } else if (count[idx] == 1) {
730 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
731 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
734 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
735 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
738 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
739 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
742 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
743 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
746 } else if (count[idx] == 2) {
748 for (i = 0; i < 3; i++)
753 for (i = t1 + 1; i < 4; i++)
758 *tx = (mvx[t1] + mvx[t2]) / 2;
759 *ty = (mvy[t1] + mvy[t2]) / 2;
767 /** Do motion compensation for 4-MV macroblock - both chroma blocks
769 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
771 MpegEncContext *s = &v->s;
772 H264ChromaContext *h264chroma = &v->h264chroma;
773 uint8_t *srcU, *srcV;
774 int uvmx, uvmy, uvsrc_x, uvsrc_y;
775 int k, tx = 0, ty = 0;
776 int mvx[4], mvy[4], intra[4], mv_f[4];
778 int chroma_ref_type = v->cur_field_type, off = 0;
779 int v_edge_pos = s->v_edge_pos >> v->field_mode;
781 if (!v->field_mode && !v->s.last_picture.f.data[0])
783 if (s->flags & CODEC_FLAG_GRAY)
786 for (k = 0; k < 4; k++) {
787 mvx[k] = s->mv[dir][k][0];
788 mvy[k] = s->mv[dir][k][1];
789 intra[k] = v->mb_type[0][s->block_index[k]];
791 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
794 /* calculate chroma MV vector from four luma MVs */
795 if (!v->field_mode || (v->field_mode && !v->numref)) {
796 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
797 chroma_ref_type = v->reffield;
799 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
800 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
801 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
802 return; //no need to do MC for intra blocks
806 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
808 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
810 chroma_ref_type = !v->cur_field_type;
812 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
814 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
815 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
816 uvmx = (tx + ((tx & 3) == 3)) >> 1;
817 uvmy = (ty + ((ty & 3) == 3)) >> 1;
819 v->luma_mv[s->mb_x][0] = uvmx;
820 v->luma_mv[s->mb_x][1] = uvmy;
823 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
824 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
826 // Field conversion bias
827 if (v->cur_field_type != chroma_ref_type)
828 uvmy += 2 - 4 * chroma_ref_type;
830 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
831 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
833 if (v->profile != PROFILE_ADVANCED) {
834 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
835 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
837 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
838 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
843 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
844 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
845 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
847 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
848 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
851 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
852 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
855 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
856 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
860 if (chroma_ref_type) {
861 srcU += s->current_picture_ptr->f.linesize[1];
862 srcV += s->current_picture_ptr->f.linesize[2];
864 off = v->cur_field_type ? s->current_picture_ptr->f.linesize[1] : 0;
867 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
868 || s->h_edge_pos < 18 || v_edge_pos < 18
869 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
870 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
871 s->vdsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
872 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
873 s->h_edge_pos >> 1, v_edge_pos >> 1);
874 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
875 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
876 s->h_edge_pos >> 1, v_edge_pos >> 1);
877 srcU = s->edge_emu_buffer;
878 srcV = s->edge_emu_buffer + 16;
880 /* if we deal with range reduction we need to scale source blocks */
881 if (v->rangeredfrm) {
887 for (j = 0; j < 9; j++) {
888 for (i = 0; i < 9; i++) {
889 src[i] = ((src[i] - 128) >> 1) + 128;
890 src2[i] = ((src2[i] - 128) >> 1) + 128;
892 src += s->uvlinesize;
893 src2 += s->uvlinesize;
896 /* if we deal with intensity compensation we need to scale source blocks */
897 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
903 for (j = 0; j < 9; j++) {
904 for (i = 0; i < 9; i++) {
905 src[i] = v->lutuv[src[i]];
906 src2[i] = v->lutuv[src2[i]];
908 src += s->uvlinesize;
909 src2 += s->uvlinesize;
914 /* Chroma MC always uses qpel bilinear */
915 uvmx = (uvmx & 3) << 1;
916 uvmy = (uvmy & 3) << 1;
918 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
919 h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
921 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
922 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
926 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
928 static void vc1_mc_4mv_chroma4(VC1Context *v)
930 MpegEncContext *s = &v->s;
931 H264ChromaContext *h264chroma = &v->h264chroma;
932 uint8_t *srcU, *srcV;
933 int uvsrc_x, uvsrc_y;
934 int uvmx_field[4], uvmy_field[4];
936 int fieldmv = v->blk_mv_type[s->block_index[0]];
937 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
938 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
939 int v_edge_pos = s->v_edge_pos >> 1;
941 if (!v->s.last_picture.f.data[0])
943 if (s->flags & CODEC_FLAG_GRAY)
946 for (i = 0; i < 4; i++) {
948 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
951 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
953 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
956 for (i = 0; i < 4; i++) {
957 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
958 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
959 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
960 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
961 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
962 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
963 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
964 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
965 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
966 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
968 if (fieldmv && !(uvsrc_y & 1))
970 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
972 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
973 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
974 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
975 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
976 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
977 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
978 s->h_edge_pos >> 1, v_edge_pos);
979 s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
980 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
981 s->h_edge_pos >> 1, v_edge_pos);
982 srcU = s->edge_emu_buffer;
983 srcV = s->edge_emu_buffer + 16;
985 /* if we deal with intensity compensation we need to scale source blocks */
986 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
992 for (j = 0; j < 5; j++) {
993 for (i = 0; i < 5; i++) {
994 src[i] = v->lutuv[src[i]];
995 src2[i] = v->lutuv[src2[i]];
997 src += s->uvlinesize << 1;
998 src2 += s->uvlinesize << 1;
1003 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1004 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1006 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1007 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1012 /***********************************************************************/
1014 * @name VC-1 Block-level functions
1015 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1021 * @brief Get macroblock-level quantizer scale
1023 #define GET_MQUANT() \
1024 if (v->dquantfrm) { \
1026 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1027 if (v->dqbilevel) { \
1028 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1030 mqdiff = get_bits(gb, 3); \
1032 mquant = v->pq + mqdiff; \
1034 mquant = get_bits(gb, 5); \
1037 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1038 edges = 1 << v->dqsbedge; \
1039 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1040 edges = (3 << v->dqsbedge) % 15; \
1041 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1043 if ((edges&1) && !s->mb_x) \
1044 mquant = v->altpq; \
1045 if ((edges&2) && s->first_slice_line) \
1046 mquant = v->altpq; \
1047 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1048 mquant = v->altpq; \
1049 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1050 mquant = v->altpq; \
1051 if (!mquant || mquant > 31) { \
1052 av_log(v->s.avctx, AV_LOG_ERROR, \
1053 "Overriding invalid mquant %d\n", mquant); \
1059 * @def GET_MVDATA(_dmv_x, _dmv_y)
1060 * @brief Get MV differentials
1061 * @see MVDATA decoding from 8.3.5.2, p(1)20
1062 * @param _dmv_x Horizontal differential for decoded MV
1063 * @param _dmv_y Vertical differential for decoded MV
1065 #define GET_MVDATA(_dmv_x, _dmv_y) \
1066 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1067 VC1_MV_DIFF_VLC_BITS, 2); \
1069 mb_has_coeffs = 1; \
1072 mb_has_coeffs = 0; \
1075 _dmv_x = _dmv_y = 0; \
1076 } else if (index == 35) { \
1077 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1078 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1079 } else if (index == 36) { \
1084 index1 = index % 6; \
1085 if (!s->quarter_sample && index1 == 5) val = 1; \
1087 if (size_table[index1] - val > 0) \
1088 val = get_bits(gb, size_table[index1] - val); \
1090 sign = 0 - (val&1); \
1091 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1093 index1 = index / 6; \
1094 if (!s->quarter_sample && index1 == 5) val = 1; \
1096 if (size_table[index1] - val > 0) \
1097 val = get_bits(gb, size_table[index1] - val); \
1099 sign = 0 - (val & 1); \
1100 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1103 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1104 int *dmv_y, int *pred_flag)
1107 int extend_x = 0, extend_y = 0;
1108 GetBitContext *gb = &v->s.gb;
1111 const int* offs_tab;
1114 bits = VC1_2REF_MVDATA_VLC_BITS;
1117 bits = VC1_1REF_MVDATA_VLC_BITS;
1120 switch (v->dmvrange) {
1128 extend_x = extend_y = 1;
1131 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1133 *dmv_x = get_bits(gb, v->k_x);
1134 *dmv_y = get_bits(gb, v->k_y);
1137 *pred_flag = *dmv_y & 1;
1138 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1140 *dmv_y = (*dmv_y + (*dmv_y & 1)) >> 1;
1146 offs_tab = offset_table2;
1148 offs_tab = offset_table1;
1149 index1 = (index + 1) % 9;
1151 val = get_bits(gb, index1 + extend_x);
1152 sign = 0 -(val & 1);
1153 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1157 offs_tab = offset_table2;
1159 offs_tab = offset_table1;
1160 index1 = (index + 1) / 9;
1161 if (index1 > v->numref) {
1162 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1163 sign = 0 - (val & 1);
1164 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1167 if (v->numref && pred_flag)
1168 *pred_flag = index1 & 1;
1172 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1174 int scaledvalue, refdist;
1175 int scalesame1, scalesame2;
1176 int scalezone1_x, zone1offset_x;
1177 int table_index = dir ^ v->second_field;
1179 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1180 refdist = v->refdist;
1182 refdist = dir ? v->brfd : v->frfd;
1185 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1186 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1187 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1188 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1193 if (FFABS(n) < scalezone1_x)
1194 scaledvalue = (n * scalesame1) >> 8;
1197 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1199 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1202 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1205 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1207 int scaledvalue, refdist;
1208 int scalesame1, scalesame2;
1209 int scalezone1_y, zone1offset_y;
1210 int table_index = dir ^ v->second_field;
1212 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1213 refdist = v->refdist;
1215 refdist = dir ? v->brfd : v->frfd;
1218 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1219 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1220 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1221 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1226 if (FFABS(n) < scalezone1_y)
1227 scaledvalue = (n * scalesame1) >> 8;
1230 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1232 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1236 if (v->cur_field_type && !v->ref_field_type[dir])
1237 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1239 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1242 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1244 int scalezone1_x, zone1offset_x;
1245 int scaleopp1, scaleopp2, brfd;
1248 brfd = FFMIN(v->brfd, 3);
1249 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1250 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1251 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1252 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1257 if (FFABS(n) < scalezone1_x)
1258 scaledvalue = (n * scaleopp1) >> 8;
1261 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1263 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1266 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1269 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1271 int scalezone1_y, zone1offset_y;
1272 int scaleopp1, scaleopp2, brfd;
1275 brfd = FFMIN(v->brfd, 3);
1276 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1277 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1278 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1279 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1284 if (FFABS(n) < scalezone1_y)
1285 scaledvalue = (n * scaleopp1) >> 8;
1288 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1290 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1293 if (v->cur_field_type && !v->ref_field_type[dir]) {
1294 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1296 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1300 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1303 int brfd, scalesame;
1304 int hpel = 1 - v->s.quarter_sample;
1307 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1309 n = scaleforsame_y(v, i, n, dir) << hpel;
1311 n = scaleforsame_x(v, n, dir) << hpel;
1314 brfd = FFMIN(v->brfd, 3);
1315 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1317 n = (n * scalesame >> 8) << hpel;
1321 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1324 int refdist, scaleopp;
1325 int hpel = 1 - v->s.quarter_sample;
1328 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1330 n = scaleforopp_y(v, n, dir) << hpel;
1332 n = scaleforopp_x(v, n) << hpel;
1335 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1336 refdist = FFMIN(v->refdist, 3);
1338 refdist = dir ? v->brfd : v->frfd;
1339 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1341 n = (n * scaleopp >> 8) << hpel;
1345 /** Predict and set motion vector
1347 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1348 int mv1, int r_x, int r_y, uint8_t* is_intra,
1349 int pred_flag, int dir)
1351 MpegEncContext *s = &v->s;
1352 int xy, wrap, off = 0;
1356 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1357 int opposite, a_f, b_f, c_f;
1358 int16_t field_predA[2];
1359 int16_t field_predB[2];
1360 int16_t field_predC[2];
1361 int a_valid, b_valid, c_valid;
1362 int hybridmv_thresh, y_bias = 0;
1364 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1365 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1369 /* scale MV difference to be quad-pel */
1370 dmv_x <<= 1 - s->quarter_sample;
1371 dmv_y <<= 1 - s->quarter_sample;
1373 wrap = s->b8_stride;
1374 xy = s->block_index[n];
1377 s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
1378 s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
1379 s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
1380 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
1381 if (mv1) { /* duplicate motion data for 1-MV block */
1382 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1383 s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1384 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1385 s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1386 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1387 s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1388 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1389 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1390 s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1391 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1392 s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1393 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1394 s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1399 C = s->current_picture.motion_val[dir][xy - 1 + v->blocks_off];
1400 A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
1402 if (v->field_mode && mixedmv_pic)
1403 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1405 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1407 //in 4-MV mode different blocks have different B predictor position
1410 off = (s->mb_x > 0) ? -1 : 1;
1413 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1422 B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
1424 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1425 b_valid = a_valid && (s->mb_width > 1);
1426 c_valid = s->mb_x || (n == 1 || n == 3);
1427 if (v->field_mode) {
1428 a_valid = a_valid && !is_intra[xy - wrap];
1429 b_valid = b_valid && !is_intra[xy - wrap + off];
1430 c_valid = c_valid && !is_intra[xy - 1];
1434 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1435 num_oppfield += a_f;
1436 num_samefield += 1 - a_f;
1437 field_predA[0] = A[0];
1438 field_predA[1] = A[1];
1440 field_predA[0] = field_predA[1] = 0;
1444 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1445 num_oppfield += b_f;
1446 num_samefield += 1 - b_f;
1447 field_predB[0] = B[0];
1448 field_predB[1] = B[1];
1450 field_predB[0] = field_predB[1] = 0;
1454 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1455 num_oppfield += c_f;
1456 num_samefield += 1 - c_f;
1457 field_predC[0] = C[0];
1458 field_predC[1] = C[1];
1460 field_predC[0] = field_predC[1] = 0;
1464 if (v->field_mode) {
1466 // REFFIELD determines if the last field or the second-last field is
1467 // to be used as reference
1468 opposite = 1 - v->reffield;
1470 if (num_samefield <= num_oppfield)
1471 opposite = 1 - pred_flag;
1473 opposite = pred_flag;
1478 if (a_valid && !a_f) {
1479 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1480 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1482 if (b_valid && !b_f) {
1483 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1484 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1486 if (c_valid && !c_f) {
1487 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1488 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1490 v->mv_f[dir][xy + v->blocks_off] = 1;
1491 v->ref_field_type[dir] = !v->cur_field_type;
1493 if (a_valid && a_f) {
1494 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1495 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1497 if (b_valid && b_f) {
1498 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1499 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1501 if (c_valid && c_f) {
1502 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1503 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1505 v->mv_f[dir][xy + v->blocks_off] = 0;
1506 v->ref_field_type[dir] = v->cur_field_type;
1510 px = field_predA[0];
1511 py = field_predA[1];
1512 } else if (c_valid) {
1513 px = field_predC[0];
1514 py = field_predC[1];
1515 } else if (b_valid) {
1516 px = field_predB[0];
1517 py = field_predB[1];
1523 if (num_samefield + num_oppfield > 1) {
1524 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1525 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1528 /* Pullback MV as specified in 8.3.5.3.4 */
1529 if (!v->field_mode) {
1531 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1532 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1533 X = (s->mb_width << 6) - 4;
1534 Y = (s->mb_height << 6) - 4;
1536 if (qx + px < -60) px = -60 - qx;
1537 if (qy + py < -60) py = -60 - qy;
1539 if (qx + px < -28) px = -28 - qx;
1540 if (qy + py < -28) py = -28 - qy;
1542 if (qx + px > X) px = X - qx;
1543 if (qy + py > Y) py = Y - qy;
1546 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1547 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1548 hybridmv_thresh = 32;
1549 if (a_valid && c_valid) {
1550 if (is_intra[xy - wrap])
1551 sum = FFABS(px) + FFABS(py);
1553 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1554 if (sum > hybridmv_thresh) {
1555 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1556 px = field_predA[0];
1557 py = field_predA[1];
1559 px = field_predC[0];
1560 py = field_predC[1];
1563 if (is_intra[xy - 1])
1564 sum = FFABS(px) + FFABS(py);
1566 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1567 if (sum > hybridmv_thresh) {
1568 if (get_bits1(&s->gb)) {
1569 px = field_predA[0];
1570 py = field_predA[1];
1572 px = field_predC[0];
1573 py = field_predC[1];
1580 if (v->field_mode && v->numref)
1582 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1584 /* store MV using signed modulus of MV range defined in 4.11 */
1585 s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1586 s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
1587 if (mv1) { /* duplicate motion data for 1-MV block */
1588 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1589 s->current_picture.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1590 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1591 s->current_picture.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1592 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1593 s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1594 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1595 v->mv_f[dir][xy + wrap + v->blocks_off] = v->mv_f[dir][xy + wrap + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1599 /** Predict and set motion vector for interlaced frame picture MBs
1601 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1602 int mvn, int r_x, int r_y, uint8_t* is_intra)
1604 MpegEncContext *s = &v->s;
1605 int xy, wrap, off = 0;
1606 int A[2], B[2], C[2];
1608 int a_valid = 0, b_valid = 0, c_valid = 0;
1609 int field_a, field_b, field_c; // 0: same, 1: opposit
1610 int total_valid, num_samefield, num_oppfield;
1611 int pos_c, pos_b, n_adj;
1613 wrap = s->b8_stride;
1614 xy = s->block_index[n];
1617 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1618 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1619 s->current_picture.motion_val[1][xy][0] = 0;
1620 s->current_picture.motion_val[1][xy][1] = 0;
1621 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1622 s->current_picture.motion_val[0][xy + 1][0] = 0;
1623 s->current_picture.motion_val[0][xy + 1][1] = 0;
1624 s->current_picture.motion_val[0][xy + wrap][0] = 0;
1625 s->current_picture.motion_val[0][xy + wrap][1] = 0;
1626 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1627 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1628 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1629 s->current_picture.motion_val[1][xy + 1][0] = 0;
1630 s->current_picture.motion_val[1][xy + 1][1] = 0;
1631 s->current_picture.motion_val[1][xy + wrap][0] = 0;
1632 s->current_picture.motion_val[1][xy + wrap][1] = 0;
1633 s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
1634 s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
1639 off = ((n == 0) || (n == 1)) ? 1 : -1;
1641 if (s->mb_x || (n == 1) || (n == 3)) {
1642 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1643 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1644 A[0] = s->current_picture.motion_val[0][xy - 1][0];
1645 A[1] = s->current_picture.motion_val[0][xy - 1][1];
1647 } else { // current block has frame mv and cand. has field MV (so average)
1648 A[0] = (s->current_picture.motion_val[0][xy - 1][0]
1649 + s->current_picture.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1650 A[1] = (s->current_picture.motion_val[0][xy - 1][1]
1651 + s->current_picture.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1654 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1660 /* Predict B and C */
1661 B[0] = B[1] = C[0] = C[1] = 0;
1662 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1663 if (!s->first_slice_line) {
1664 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1667 pos_b = s->block_index[n_adj] - 2 * wrap;
1668 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1669 n_adj = (n & 2) | (n & 1);
1671 B[0] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1672 B[1] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1673 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1674 B[0] = (B[0] + s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1675 B[1] = (B[1] + s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1678 if (s->mb_width > 1) {
1679 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1682 pos_c = s->block_index[2] - 2 * wrap + 2;
1683 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1686 C[0] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1687 C[1] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1688 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1689 C[0] = (1 + C[0] + (s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1690 C[1] = (1 + C[1] + (s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1692 if (s->mb_x == s->mb_width - 1) {
1693 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1696 pos_c = s->block_index[3] - 2 * wrap - 2;
1697 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1700 C[0] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1701 C[1] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1702 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1703 C[0] = (1 + C[0] + s->current_picture.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1704 C[1] = (1 + C[1] + s->current_picture.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1713 pos_b = s->block_index[1];
1715 B[0] = s->current_picture.motion_val[0][pos_b][0];
1716 B[1] = s->current_picture.motion_val[0][pos_b][1];
1717 pos_c = s->block_index[0];
1719 C[0] = s->current_picture.motion_val[0][pos_c][0];
1720 C[1] = s->current_picture.motion_val[0][pos_c][1];
1723 total_valid = a_valid + b_valid + c_valid;
1724 // check if predictor A is out of bounds
1725 if (!s->mb_x && !(n == 1 || n == 3)) {
1728 // check if predictor B is out of bounds
1729 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1730 B[0] = B[1] = C[0] = C[1] = 0;
1732 if (!v->blk_mv_type[xy]) {
1733 if (s->mb_width == 1) {
1737 if (total_valid >= 2) {
1738 px = mid_pred(A[0], B[0], C[0]);
1739 py = mid_pred(A[1], B[1], C[1]);
1740 } else if (total_valid) {
1741 if (a_valid) { px = A[0]; py = A[1]; }
1742 if (b_valid) { px = B[0]; py = B[1]; }
1743 if (c_valid) { px = C[0]; py = C[1]; }
1749 field_a = (A[1] & 4) ? 1 : 0;
1753 field_b = (B[1] & 4) ? 1 : 0;
1757 field_c = (C[1] & 4) ? 1 : 0;
1761 num_oppfield = field_a + field_b + field_c;
1762 num_samefield = total_valid - num_oppfield;
1763 if (total_valid == 3) {
1764 if ((num_samefield == 3) || (num_oppfield == 3)) {
1765 px = mid_pred(A[0], B[0], C[0]);
1766 py = mid_pred(A[1], B[1], C[1]);
1767 } else if (num_samefield >= num_oppfield) {
1768 /* take one MV from same field set depending on priority
1769 the check for B may not be necessary */
1770 px = !field_a ? A[0] : B[0];
1771 py = !field_a ? A[1] : B[1];
1773 px = field_a ? A[0] : B[0];
1774 py = field_a ? A[1] : B[1];
1776 } else if (total_valid == 2) {
1777 if (num_samefield >= num_oppfield) {
1778 if (!field_a && a_valid) {
1781 } else if (!field_b && b_valid) {
1784 } else if (c_valid) {
1789 if (field_a && a_valid) {
1792 } else if (field_b && b_valid) {
1795 } else if (c_valid) {
1800 } else if (total_valid == 1) {
1801 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1802 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1807 /* store MV using signed modulus of MV range defined in 4.11 */
1808 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1809 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1810 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1811 s->current_picture.motion_val[0][xy + 1 ][0] = s->current_picture.motion_val[0][xy][0];
1812 s->current_picture.motion_val[0][xy + 1 ][1] = s->current_picture.motion_val[0][xy][1];
1813 s->current_picture.motion_val[0][xy + wrap ][0] = s->current_picture.motion_val[0][xy][0];
1814 s->current_picture.motion_val[0][xy + wrap ][1] = s->current_picture.motion_val[0][xy][1];
1815 s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
1816 s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
1817 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1818 s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
1819 s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
1820 s->mv[0][n + 1][0] = s->mv[0][n][0];
1821 s->mv[0][n + 1][1] = s->mv[0][n][1];
1825 /** Motion compensation for direct or interpolated blocks in B-frames
1827 static void vc1_interp_mc(VC1Context *v)
1829 MpegEncContext *s = &v->s;
1830 H264ChromaContext *h264chroma = &v->h264chroma;
1831 uint8_t *srcY, *srcU, *srcV;
1832 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1834 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1836 if (!v->field_mode && !v->s.next_picture.f.data[0])
1839 mx = s->mv[1][0][0];
1840 my = s->mv[1][0][1];
1841 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1842 uvmy = (my + ((my & 3) == 3)) >> 1;
1843 if (v->field_mode) {
1844 if (v->cur_field_type != v->ref_field_type[1])
1845 my = my - 2 + 4 * v->cur_field_type;
1846 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1849 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1850 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1852 srcY = s->next_picture.f.data[0];
1853 srcU = s->next_picture.f.data[1];
1854 srcV = s->next_picture.f.data[2];
1856 src_x = s->mb_x * 16 + (mx >> 2);
1857 src_y = s->mb_y * 16 + (my >> 2);
1858 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1859 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1861 if (v->profile != PROFILE_ADVANCED) {
1862 src_x = av_clip( src_x, -16, s->mb_width * 16);
1863 src_y = av_clip( src_y, -16, s->mb_height * 16);
1864 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1865 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1867 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1868 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1869 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1870 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1873 srcY += src_y * s->linesize + src_x;
1874 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1875 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1877 if (v->field_mode && v->ref_field_type[1]) {
1878 srcY += s->current_picture_ptr->f.linesize[0];
1879 srcU += s->current_picture_ptr->f.linesize[1];
1880 srcV += s->current_picture_ptr->f.linesize[2];
1883 /* for grayscale we should not try to read from unknown area */
1884 if (s->flags & CODEC_FLAG_GRAY) {
1885 srcU = s->edge_emu_buffer + 18 * s->linesize;
1886 srcV = s->edge_emu_buffer + 18 * s->linesize;
1889 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1890 || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1891 || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1892 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1894 srcY -= s->mspel * (1 + s->linesize);
1895 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1896 17 + s->mspel * 2, 17 + s->mspel * 2,
1897 src_x - s->mspel, src_y - s->mspel,
1898 s->h_edge_pos, v_edge_pos);
1899 srcY = s->edge_emu_buffer;
1900 s->vdsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1901 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1902 s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1903 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1906 /* if we deal with range reduction we need to scale source blocks */
1907 if (v->rangeredfrm) {
1909 uint8_t *src, *src2;
1912 for (j = 0; j < 17 + s->mspel * 2; j++) {
1913 for (i = 0; i < 17 + s->mspel * 2; i++)
1914 src[i] = ((src[i] - 128) >> 1) + 128;
1919 for (j = 0; j < 9; j++) {
1920 for (i = 0; i < 9; i++) {
1921 src[i] = ((src[i] - 128) >> 1) + 128;
1922 src2[i] = ((src2[i] - 128) >> 1) + 128;
1924 src += s->uvlinesize;
1925 src2 += s->uvlinesize;
1928 srcY += s->mspel * (1 + s->linesize);
1931 if (v->field_mode && v->cur_field_type) {
1932 off = s->current_picture_ptr->f.linesize[0];
1933 off_uv = s->current_picture_ptr->f.linesize[1];
1940 dxy = ((my & 3) << 2) | (mx & 3);
1941 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
1942 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1943 srcY += s->linesize * 8;
1944 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
1945 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1947 dxy = (my & 2) | ((mx & 2) >> 1);
1950 s->hdsp.avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1952 s->hdsp.avg_no_rnd_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, 16);
1955 if (s->flags & CODEC_FLAG_GRAY) return;
1956 /* Chroma MC always uses qpel blilinear */
1957 uvmx = (uvmx & 3) << 1;
1958 uvmy = (uvmy & 3) << 1;
1960 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1961 h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1963 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1964 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1968 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1972 #if B_FRACTION_DEN==256
1976 return 2 * ((value * n + 255) >> 9);
1977 return (value * n + 128) >> 8;
1980 n -= B_FRACTION_DEN;
1982 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1983 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1987 /** Reconstruct motion vector for B-frame and do motion compensation
1989 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
1990 int direct, int mode)
1993 v->mv_mode2 = v->mv_mode;
1994 v->mv_mode = MV_PMODE_INTENSITY_COMP;
2000 v->mv_mode = v->mv_mode2;
2003 if (mode == BMV_TYPE_INTERPOLATED) {
2007 v->mv_mode = v->mv_mode2;
2011 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2012 v->mv_mode = v->mv_mode2;
2013 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2015 v->mv_mode = v->mv_mode2;
2018 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2019 int direct, int mvtype)
2021 MpegEncContext *s = &v->s;
2022 int xy, wrap, off = 0;
2027 const uint8_t *is_intra = v->mb_type[0];
2031 /* scale MV difference to be quad-pel */
2032 dmv_x[0] <<= 1 - s->quarter_sample;
2033 dmv_y[0] <<= 1 - s->quarter_sample;
2034 dmv_x[1] <<= 1 - s->quarter_sample;
2035 dmv_y[1] <<= 1 - s->quarter_sample;
2037 wrap = s->b8_stride;
2038 xy = s->block_index[0];
2041 s->current_picture.motion_val[0][xy + v->blocks_off][0] =
2042 s->current_picture.motion_val[0][xy + v->blocks_off][1] =
2043 s->current_picture.motion_val[1][xy + v->blocks_off][0] =
2044 s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
2047 if (!v->field_mode) {
2048 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2049 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2050 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2051 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2053 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2054 s->mv[0][0][0] = av_clip(s->mv[0][0][0], -60 - (s->mb_x << 6), (s->mb_width << 6) - 4 - (s->mb_x << 6));
2055 s->mv[0][0][1] = av_clip(s->mv[0][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
2056 s->mv[1][0][0] = av_clip(s->mv[1][0][0], -60 - (s->mb_x << 6), (s->mb_width << 6) - 4 - (s->mb_x << 6));
2057 s->mv[1][0][1] = av_clip(s->mv[1][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
2060 s->current_picture.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2061 s->current_picture.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2062 s->current_picture.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2063 s->current_picture.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2067 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2068 C = s->current_picture.motion_val[0][xy - 2];
2069 A = s->current_picture.motion_val[0][xy - wrap * 2];
2070 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2071 B = s->current_picture.motion_val[0][xy - wrap * 2 + off];
2073 if (!s->mb_x) C[0] = C[1] = 0;
2074 if (!s->first_slice_line) { // predictor A is not out of bounds
2075 if (s->mb_width == 1) {
2079 px = mid_pred(A[0], B[0], C[0]);
2080 py = mid_pred(A[1], B[1], C[1]);
2082 } else if (s->mb_x) { // predictor C is not out of bounds
2088 /* Pullback MV as specified in 8.3.5.3.4 */
2091 if (v->profile < PROFILE_ADVANCED) {
2092 qx = (s->mb_x << 5);
2093 qy = (s->mb_y << 5);
2094 X = (s->mb_width << 5) - 4;
2095 Y = (s->mb_height << 5) - 4;
2096 if (qx + px < -28) px = -28 - qx;
2097 if (qy + py < -28) py = -28 - qy;
2098 if (qx + px > X) px = X - qx;
2099 if (qy + py > Y) py = Y - qy;
2101 qx = (s->mb_x << 6);
2102 qy = (s->mb_y << 6);
2103 X = (s->mb_width << 6) - 4;
2104 Y = (s->mb_height << 6) - 4;
2105 if (qx + px < -60) px = -60 - qx;
2106 if (qy + py < -60) py = -60 - qy;
2107 if (qx + px > X) px = X - qx;
2108 if (qy + py > Y) py = Y - qy;
2111 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2112 if (0 && !s->first_slice_line && s->mb_x) {
2113 if (is_intra[xy - wrap])
2114 sum = FFABS(px) + FFABS(py);
2116 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2118 if (get_bits1(&s->gb)) {
2126 if (is_intra[xy - 2])
2127 sum = FFABS(px) + FFABS(py);
2129 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2131 if (get_bits1(&s->gb)) {
2141 /* store MV using signed modulus of MV range defined in 4.11 */
2142 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2143 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2145 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2146 C = s->current_picture.motion_val[1][xy - 2];
2147 A = s->current_picture.motion_val[1][xy - wrap * 2];
2148 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2149 B = s->current_picture.motion_val[1][xy - wrap * 2 + off];
2153 if (!s->first_slice_line) { // predictor A is not out of bounds
2154 if (s->mb_width == 1) {
2158 px = mid_pred(A[0], B[0], C[0]);
2159 py = mid_pred(A[1], B[1], C[1]);
2161 } else if (s->mb_x) { // predictor C is not out of bounds
2167 /* Pullback MV as specified in 8.3.5.3.4 */
2170 if (v->profile < PROFILE_ADVANCED) {
2171 qx = (s->mb_x << 5);
2172 qy = (s->mb_y << 5);
2173 X = (s->mb_width << 5) - 4;
2174 Y = (s->mb_height << 5) - 4;
2175 if (qx + px < -28) px = -28 - qx;
2176 if (qy + py < -28) py = -28 - qy;
2177 if (qx + px > X) px = X - qx;
2178 if (qy + py > Y) py = Y - qy;
2180 qx = (s->mb_x << 6);
2181 qy = (s->mb_y << 6);
2182 X = (s->mb_width << 6) - 4;
2183 Y = (s->mb_height << 6) - 4;
2184 if (qx + px < -60) px = -60 - qx;
2185 if (qy + py < -60) py = -60 - qy;
2186 if (qx + px > X) px = X - qx;
2187 if (qy + py > Y) py = Y - qy;
2190 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2191 if (0 && !s->first_slice_line && s->mb_x) {
2192 if (is_intra[xy - wrap])
2193 sum = FFABS(px) + FFABS(py);
2195 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2197 if (get_bits1(&s->gb)) {
2205 if (is_intra[xy - 2])
2206 sum = FFABS(px) + FFABS(py);
2208 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2210 if (get_bits1(&s->gb)) {
2220 /* store MV using signed modulus of MV range defined in 4.11 */
2222 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2223 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2225 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2226 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2227 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2228 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2231 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2233 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2234 MpegEncContext *s = &v->s;
2235 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2237 if (v->bmvtype == BMV_TYPE_DIRECT) {
2238 int total_opp, k, f;
2239 if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2240 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2241 v->bfraction, 0, s->quarter_sample);
2242 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2243 v->bfraction, 0, s->quarter_sample);
2244 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2245 v->bfraction, 1, s->quarter_sample);
2246 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2247 v->bfraction, 1, s->quarter_sample);
2249 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2250 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2251 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2252 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2253 f = (total_opp > 2) ? 1 : 0;
2255 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2256 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2259 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2260 for (k = 0; k < 4; k++) {
2261 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2262 s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2263 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2264 s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2265 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2266 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2270 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2271 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], pred_flag[0], 0);
2272 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], pred_flag[1], 1);
2275 if (dir) { // backward
2276 vc1_pred_mv(v, n, dmv_x[1], dmv_y[1], mv1, v->range_x, v->range_y, v->mb_type[0], pred_flag[1], 1);
2277 if (n == 3 || mv1) {
2278 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2281 vc1_pred_mv(v, n, dmv_x[0], dmv_y[0], mv1, v->range_x, v->range_y, v->mb_type[0], pred_flag[0], 0);
2282 if (n == 3 || mv1) {
2283 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2288 /** Get predicted DC value for I-frames only
2289 * prediction dir: left=0, top=1
2290 * @param s MpegEncContext
2291 * @param overlap flag indicating that overlap filtering is used
2292 * @param pq integer part of picture quantizer
2293 * @param[in] n block index in the current MB
2294 * @param dc_val_ptr Pointer to DC predictor
2295 * @param dir_ptr Prediction direction for use in AC prediction
2297 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2298 int16_t **dc_val_ptr, int *dir_ptr)
2300 int a, b, c, wrap, pred, scale;
2302 static const uint16_t dcpred[32] = {
2303 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2304 114, 102, 93, 85, 79, 73, 68, 64,
2305 60, 57, 54, 51, 49, 47, 45, 43,
2306 41, 39, 38, 37, 35, 34, 33
2309 /* find prediction - wmv3_dc_scale always used here in fact */
2310 if (n < 4) scale = s->y_dc_scale;
2311 else scale = s->c_dc_scale;
2313 wrap = s->block_wrap[n];
2314 dc_val = s->dc_val[0] + s->block_index[n];
2320 b = dc_val[ - 1 - wrap];
2321 a = dc_val[ - wrap];
2323 if (pq < 9 || !overlap) {
2324 /* Set outer values */
2325 if (s->first_slice_line && (n != 2 && n != 3))
2326 b = a = dcpred[scale];
2327 if (s->mb_x == 0 && (n != 1 && n != 3))
2328 b = c = dcpred[scale];
2330 /* Set outer values */
2331 if (s->first_slice_line && (n != 2 && n != 3))
2333 if (s->mb_x == 0 && (n != 1 && n != 3))
2337 if (abs(a - b) <= abs(b - c)) {
2339 *dir_ptr = 1; // left
2342 *dir_ptr = 0; // top
2345 /* update predictor */
2346 *dc_val_ptr = &dc_val[0];
2351 /** Get predicted DC value
2352 * prediction dir: left=0, top=1
2353 * @param s MpegEncContext
2354 * @param overlap flag indicating that overlap filtering is used
2355 * @param pq integer part of picture quantizer
2356 * @param[in] n block index in the current MB
2357 * @param a_avail flag indicating top block availability
2358 * @param c_avail flag indicating left block availability
2359 * @param dc_val_ptr Pointer to DC predictor
2360 * @param dir_ptr Prediction direction for use in AC prediction
2362 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2363 int a_avail, int c_avail,
2364 int16_t **dc_val_ptr, int *dir_ptr)
2366 int a, b, c, wrap, pred;
2368 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2372 wrap = s->block_wrap[n];
2373 dc_val = s->dc_val[0] + s->block_index[n];
2379 b = dc_val[ - 1 - wrap];
2380 a = dc_val[ - wrap];
2381 /* scale predictors if needed */
2382 q1 = s->current_picture.qscale_table[mb_pos];
2383 dqscale_index = s->y_dc_scale_table[q1] - 1;
2384 if (dqscale_index < 0)
2386 if (c_avail && (n != 1 && n != 3)) {
2387 q2 = s->current_picture.qscale_table[mb_pos - 1];
2389 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2391 if (a_avail && (n != 2 && n != 3)) {
2392 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2394 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2396 if (a_avail && c_avail && (n != 3)) {
2401 off -= s->mb_stride;
2402 q2 = s->current_picture.qscale_table[off];
2404 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2407 if (a_avail && c_avail) {
2408 if (abs(a - b) <= abs(b - c)) {
2410 *dir_ptr = 1; // left
2413 *dir_ptr = 0; // top
2415 } else if (a_avail) {
2417 *dir_ptr = 0; // top
2418 } else if (c_avail) {
2420 *dir_ptr = 1; // left
2423 *dir_ptr = 1; // left
2426 /* update predictor */
2427 *dc_val_ptr = &dc_val[0];
2431 /** @} */ // Block group
2434 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2435 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2439 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2440 uint8_t **coded_block_ptr)
2442 int xy, wrap, pred, a, b, c;
2444 xy = s->block_index[n];
2445 wrap = s->b8_stride;
2450 a = s->coded_block[xy - 1 ];
2451 b = s->coded_block[xy - 1 - wrap];
2452 c = s->coded_block[xy - wrap];
2461 *coded_block_ptr = &s->coded_block[xy];
2467 * Decode one AC coefficient
2468 * @param v The VC1 context
2469 * @param last Last coefficient
2470 * @param skip How much zero coefficients to skip
2471 * @param value Decoded AC coefficient value
2472 * @param codingset set of VLC to decode data
2475 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2476 int *value, int codingset)
2478 GetBitContext *gb = &v->s.gb;
2479 int index, escape, run = 0, level = 0, lst = 0;
2481 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2482 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2483 run = vc1_index_decode_table[codingset][index][0];
2484 level = vc1_index_decode_table[codingset][index][1];
2485 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2489 escape = decode210(gb);
2491 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2492 run = vc1_index_decode_table[codingset][index][0];
2493 level = vc1_index_decode_table[codingset][index][1];
2494 lst = index >= vc1_last_decode_table[codingset];
2497 level += vc1_last_delta_level_table[codingset][run];
2499 level += vc1_delta_level_table[codingset][run];
2502 run += vc1_last_delta_run_table[codingset][level] + 1;
2504 run += vc1_delta_run_table[codingset][level] + 1;
2510 lst = get_bits1(gb);
2511 if (v->s.esc3_level_length == 0) {
2512 if (v->pq < 8 || v->dquantfrm) { // table 59
2513 v->s.esc3_level_length = get_bits(gb, 3);
2514 if (!v->s.esc3_level_length)
2515 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2516 } else { // table 60
2517 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2519 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2521 run = get_bits(gb, v->s.esc3_run_length);
2522 sign = get_bits1(gb);
2523 level = get_bits(gb, v->s.esc3_level_length);
2534 /** Decode intra block in intra frames - should be faster than decode_intra_block
2535 * @param v VC1Context
2536 * @param block block to decode
2537 * @param[in] n subblock index
2538 * @param coded are AC coeffs present or not
2539 * @param codingset set of VLC to decode data
2541 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
2542 int coded, int codingset)
2544 GetBitContext *gb = &v->s.gb;
2545 MpegEncContext *s = &v->s;
2546 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2549 int16_t *ac_val, *ac_val2;
2552 /* Get DC differential */
2554 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2556 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2559 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2563 if (dcdiff == 119 /* ESC index value */) {
2564 /* TODO: Optimize */
2565 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2566 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2567 else dcdiff = get_bits(gb, 8);
2570 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2571 else if (v->pq == 2)
2572 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2579 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2582 /* Store the quantized DC coeff, used for prediction */
2584 block[0] = dcdiff * s->y_dc_scale;
2586 block[0] = dcdiff * s->c_dc_scale;
2597 int last = 0, skip, value;
2598 const uint8_t *zz_table;
2602 scale = v->pq * 2 + v->halfpq;
2606 zz_table = v->zz_8x8[2];
2608 zz_table = v->zz_8x8[3];
2610 zz_table = v->zz_8x8[1];
2612 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2614 if (dc_pred_dir) // left
2617 ac_val -= 16 * s->block_wrap[n];
2620 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2624 block[zz_table[i++]] = value;
2627 /* apply AC prediction if needed */
2629 if (dc_pred_dir) { // left
2630 for (k = 1; k < 8; k++)
2631 block[k << v->left_blk_sh] += ac_val[k];
2633 for (k = 1; k < 8; k++)
2634 block[k << v->top_blk_sh] += ac_val[k + 8];
2637 /* save AC coeffs for further prediction */
2638 for (k = 1; k < 8; k++) {
2639 ac_val2[k] = block[k << v->left_blk_sh];
2640 ac_val2[k + 8] = block[k << v->top_blk_sh];
2643 /* scale AC coeffs */
2644 for (k = 1; k < 64; k++)
2648 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2651 if (s->ac_pred) i = 63;
2657 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2661 scale = v->pq * 2 + v->halfpq;
2662 memset(ac_val2, 0, 16 * 2);
2663 if (dc_pred_dir) { // left
2666 memcpy(ac_val2, ac_val, 8 * 2);
2668 ac_val -= 16 * s->block_wrap[n];
2670 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2673 /* apply AC prediction if needed */
2675 if (dc_pred_dir) { //left
2676 for (k = 1; k < 8; k++) {
2677 block[k << v->left_blk_sh] = ac_val[k] * scale;
2678 if (!v->pquantizer && block[k << v->left_blk_sh])
2679 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2682 for (k = 1; k < 8; k++) {
2683 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2684 if (!v->pquantizer && block[k << v->top_blk_sh])
2685 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2691 s->block_last_index[n] = i;
2696 /** Decode intra block in intra frames - should be faster than decode_intra_block
2697 * @param v VC1Context
2698 * @param block block to decode
2699 * @param[in] n subblock number
2700 * @param coded are AC coeffs present or not
2701 * @param codingset set of VLC to decode data
2702 * @param mquant quantizer value for this macroblock
2704 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
2705 int coded, int codingset, int mquant)
2707 GetBitContext *gb = &v->s.gb;
2708 MpegEncContext *s = &v->s;
2709 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2712 int16_t *ac_val, *ac_val2;
2714 int a_avail = v->a_avail, c_avail = v->c_avail;
2715 int use_pred = s->ac_pred;
2718 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2720 /* Get DC differential */
2722 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2724 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2727 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2731 if (dcdiff == 119 /* ESC index value */) {
2732 /* TODO: Optimize */
2733 if (mquant == 1) dcdiff = get_bits(gb, 10);
2734 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2735 else dcdiff = get_bits(gb, 8);
2738 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2739 else if (mquant == 2)
2740 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2747 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2750 /* Store the quantized DC coeff, used for prediction */
2752 block[0] = dcdiff * s->y_dc_scale;
2754 block[0] = dcdiff * s->c_dc_scale;
2760 /* check if AC is needed at all */
2761 if (!a_avail && !c_avail)
2763 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2766 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2768 if (dc_pred_dir) // left
2771 ac_val -= 16 * s->block_wrap[n];
2773 q1 = s->current_picture.qscale_table[mb_pos];
2774 if ( dc_pred_dir && c_avail && mb_pos)
2775 q2 = s->current_picture.qscale_table[mb_pos - 1];
2776 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2777 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2778 if ( dc_pred_dir && n == 1)
2780 if (!dc_pred_dir && n == 2)
2786 int last = 0, skip, value;
2787 const uint8_t *zz_table;
2791 if (!use_pred && v->fcm == ILACE_FRAME) {
2792 zz_table = v->zzi_8x8;
2794 if (!dc_pred_dir) // top
2795 zz_table = v->zz_8x8[2];
2797 zz_table = v->zz_8x8[3];
2800 if (v->fcm != ILACE_FRAME)
2801 zz_table = v->zz_8x8[1];
2803 zz_table = v->zzi_8x8;
2807 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2811 block[zz_table[i++]] = value;
2814 /* apply AC prediction if needed */
2816 /* scale predictors if needed*/
2817 if (q2 && q1 != q2) {
2818 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2819 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2822 return AVERROR_INVALIDDATA;
2823 if (dc_pred_dir) { // left
2824 for (k = 1; k < 8; k++)
2825 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2827 for (k = 1; k < 8; k++)
2828 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2831 if (dc_pred_dir) { //left
2832 for (k = 1; k < 8; k++)
2833 block[k << v->left_blk_sh] += ac_val[k];
2835 for (k = 1; k < 8; k++)
2836 block[k << v->top_blk_sh] += ac_val[k + 8];
2840 /* save AC coeffs for further prediction */
2841 for (k = 1; k < 8; k++) {
2842 ac_val2[k ] = block[k << v->left_blk_sh];
2843 ac_val2[k + 8] = block[k << v->top_blk_sh];
2846 /* scale AC coeffs */
2847 for (k = 1; k < 64; k++)
2851 block[k] += (block[k] < 0) ? -mquant : mquant;
2854 if (use_pred) i = 63;
2855 } else { // no AC coeffs
2858 memset(ac_val2, 0, 16 * 2);
2859 if (dc_pred_dir) { // left
2861 memcpy(ac_val2, ac_val, 8 * 2);
2862 if (q2 && q1 != q2) {
2863 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2864 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2866 return AVERROR_INVALIDDATA;
2867 for (k = 1; k < 8; k++)
2868 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2873 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2874 if (q2 && q1 != q2) {
2875 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2876 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2878 return AVERROR_INVALIDDATA;
2879 for (k = 1; k < 8; k++)
2880 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2885 /* apply AC prediction if needed */
2887 if (dc_pred_dir) { // left
2888 for (k = 1; k < 8; k++) {
2889 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2890 if (!v->pquantizer && block[k << v->left_blk_sh])
2891 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2894 for (k = 1; k < 8; k++) {
2895 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2896 if (!v->pquantizer && block[k << v->top_blk_sh])
2897 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2903 s->block_last_index[n] = i;
2908 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2909 * @param v VC1Context
2910 * @param block block to decode
2911 * @param[in] n subblock index
2912 * @param coded are AC coeffs present or not
2913 * @param mquant block quantizer
2914 * @param codingset set of VLC to decode data
2916 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
2917 int coded, int mquant, int codingset)
2919 GetBitContext *gb = &v->s.gb;
2920 MpegEncContext *s = &v->s;
2921 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2924 int16_t *ac_val, *ac_val2;
2926 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2927 int a_avail = v->a_avail, c_avail = v->c_avail;
2928 int use_pred = s->ac_pred;
2932 s->dsp.clear_block(block);
2934 /* XXX: Guard against dumb values of mquant */
2935 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2937 /* Set DC scale - y and c use the same */
2938 s->y_dc_scale = s->y_dc_scale_table[mquant];
2939 s->c_dc_scale = s->c_dc_scale_table[mquant];
2941 /* Get DC differential */
2943 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2945 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2948 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2952 if (dcdiff == 119 /* ESC index value */) {
2953 /* TODO: Optimize */
2954 if (mquant == 1) dcdiff = get_bits(gb, 10);
2955 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2956 else dcdiff = get_bits(gb, 8);
2959 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2960 else if (mquant == 2)
2961 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2968 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2971 /* Store the quantized DC coeff, used for prediction */
2974 block[0] = dcdiff * s->y_dc_scale;
2976 block[0] = dcdiff * s->c_dc_scale;
2982 /* check if AC is needed at all and adjust direction if needed */
2983 if (!a_avail) dc_pred_dir = 1;
2984 if (!c_avail) dc_pred_dir = 0;
2985 if (!a_avail && !c_avail) use_pred = 0;
2986 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2989 scale = mquant * 2 + v->halfpq;
2991 if (dc_pred_dir) //left
2994 ac_val -= 16 * s->block_wrap[n];
2996 q1 = s->current_picture.qscale_table[mb_pos];
2997 if (dc_pred_dir && c_avail && mb_pos)
2998 q2 = s->current_picture.qscale_table[mb_pos - 1];
2999 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3000 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3001 if ( dc_pred_dir && n == 1)
3003 if (!dc_pred_dir && n == 2)
3005 if (n == 3) q2 = q1;
3008 int last = 0, skip, value;
3012 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3016 if (v->fcm == PROGRESSIVE)
3017 block[v->zz_8x8[0][i++]] = value;
3019 if (use_pred && (v->fcm == ILACE_FRAME)) {
3020 if (!dc_pred_dir) // top
3021 block[v->zz_8x8[2][i++]] = value;
3023 block[v->zz_8x8[3][i++]] = value;
3025 block[v->zzi_8x8[i++]] = value;
3030 /* apply AC prediction if needed */
3032 /* scale predictors if needed*/
3033 if (q2 && q1 != q2) {
3034 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3035 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3038 return AVERROR_INVALIDDATA;
3039 if (dc_pred_dir) { // left
3040 for (k = 1; k < 8; k++)
3041 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3043 for (k = 1; k < 8; k++)
3044 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3047 if (dc_pred_dir) { // left
3048 for (k = 1; k < 8; k++)
3049 block[k << v->left_blk_sh] += ac_val[k];
3051 for (k = 1; k < 8; k++)
3052 block[k << v->top_blk_sh] += ac_val[k + 8];
3056 /* save AC coeffs for further prediction */
3057 for (k = 1; k < 8; k++) {
3058 ac_val2[k ] = block[k << v->left_blk_sh];
3059 ac_val2[k + 8] = block[k << v->top_blk_sh];
3062 /* scale AC coeffs */
3063 for (k = 1; k < 64; k++)
3067 block[k] += (block[k] < 0) ? -mquant : mquant;
3070 if (use_pred) i = 63;
3071 } else { // no AC coeffs
3074 memset(ac_val2, 0, 16 * 2);
3075 if (dc_pred_dir) { // left
3077 memcpy(ac_val2, ac_val, 8 * 2);
3078 if (q2 && q1 != q2) {
3079 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3080 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3082 return AVERROR_INVALIDDATA;
3083 for (k = 1; k < 8; k++)
3084 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3089 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3090 if (q2 && q1 != q2) {
3091 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3092 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3094 return AVERROR_INVALIDDATA;
3095 for (k = 1; k < 8; k++)
3096 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3101 /* apply AC prediction if needed */
3103 if (dc_pred_dir) { // left
3104 for (k = 1; k < 8; k++) {
3105 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3106 if (!v->pquantizer && block[k << v->left_blk_sh])
3107 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3110 for (k = 1; k < 8; k++) {
3111 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3112 if (!v->pquantizer && block[k << v->top_blk_sh])
3113 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3119 s->block_last_index[n] = i;
3126 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
3127 int mquant, int ttmb, int first_block,
3128 uint8_t *dst, int linesize, int skip_block,
3131 MpegEncContext *s = &v->s;
3132 GetBitContext *gb = &s->gb;
3135 int scale, off, idx, last, skip, value;
3136 int ttblk = ttmb & 7;
3139 s->dsp.clear_block(block);
3142 ttblk = ff_vc1_ttblk_to_tt[v->tt_index][get_vlc2(gb, ff_vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
3144 if (ttblk == TT_4X4) {
3145 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3147 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3148 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3149 || (!v->res_rtm_flag && !first_block))) {
3150 subblkpat = decode012(gb);
3152 subblkpat ^= 3; // swap decoded pattern bits
3153 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3155 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3158 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3160 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3161 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3162 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3165 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3166 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3175 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3180 idx = v->zz_8x8[0][i++];
3182 idx = v->zzi_8x8[i++];
3183 block[idx] = value * scale;
3185 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3189 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3191 v->vc1dsp.vc1_inv_trans_8x8(block);
3192 s->dsp.add_pixels_clamped(block, dst, linesize);
3197 pat = ~subblkpat & 0xF;
3198 for (j = 0; j < 4; j++) {
3199 last = subblkpat & (1 << (3 - j));
3201 off = (j & 1) * 4 + (j & 2) * 16;
3203 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3208 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3210 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3211 block[idx + off] = value * scale;
3213 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3215 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3217 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3219 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3224 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3225 for (j = 0; j < 2; j++) {
3226 last = subblkpat & (1 << (1 - j));
3230 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3235 idx = v->zz_8x4[i++] + off;
3237 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3238 block[idx] = value * scale;
3240 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3242 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3244 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3246 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3251 pat = ~(subblkpat * 5) & 0xF;
3252 for (j = 0; j < 2; j++) {
3253 last = subblkpat & (1 << (1 - j));
3257 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3262 idx = v->zz_4x8[i++] + off;
3264 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3265 block[idx] = value * scale;
3267 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3269 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3271 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3273 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3279 *ttmb_out |= ttblk << (n * 4);
3283 /** @} */ // Macroblock group
3285 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3286 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3288 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3290 MpegEncContext *s = &v->s;
3291 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3292 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3293 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3294 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3295 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3298 if (block_num > 3) {
3299 dst = s->dest[block_num - 3];
3301 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3303 if (s->mb_y != s->end_mb_y || block_num < 2) {
3307 if (block_num > 3) {
3308 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3309 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3310 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3311 mv_stride = s->mb_stride;
3313 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3314 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3315 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3316 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3317 mv_stride = s->b8_stride;
3318 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3321 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3322 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3323 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3325 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3327 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3330 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3332 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3337 dst -= 4 * linesize;
3338 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3339 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3340 idx = (block_cbp | (block_cbp >> 2)) & 3;
3342 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3345 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3347 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3352 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3354 MpegEncContext *s = &v->s;
3355 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3356 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3357 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3358 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3359 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3362 if (block_num > 3) {
3363 dst = s->dest[block_num - 3] - 8 * linesize;
3365 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3368 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3371 if (block_num > 3) {
3372 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3373 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3374 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3376 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3377 : (mb_cbp >> ((block_num + 1) * 4));
3378 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3379 : (mb_is_intra >> ((block_num + 1) * 4));
3380 mv = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3382 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3383 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3385 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3387 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3390 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3392 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3398 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3399 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3400 idx = (block_cbp | (block_cbp >> 1)) & 5;
3402 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3405 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3407 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3412 static void vc1_apply_p_loop_filter(VC1Context *v)
3414 MpegEncContext *s = &v->s;
3417 for (i = 0; i < 6; i++) {
3418 vc1_apply_p_v_loop_filter(v, i);
3421 /* V always precedes H, therefore we run H one MB before V;
3422 * at the end of a row, we catch up to complete the row */
3424 for (i = 0; i < 6; i++) {
3425 vc1_apply_p_h_loop_filter(v, i);
3427 if (s->mb_x == s->mb_width - 1) {
3429 ff_update_block_index(s);
3430 for (i = 0; i < 6; i++) {
3431 vc1_apply_p_h_loop_filter(v, i);
3437 /** Decode one P-frame MB
3439 static int vc1_decode_p_mb(VC1Context *v)
3441 MpegEncContext *s = &v->s;
3442 GetBitContext *gb = &s->gb;
3444 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3445 int cbp; /* cbp decoding stuff */
3446 int mqdiff, mquant; /* MB quantization */
3447 int ttmb = v->ttfrm; /* MB Transform type */
3449 int mb_has_coeffs = 1; /* last_flag */
3450 int dmv_x, dmv_y; /* Differential MV components */
3451 int index, index1; /* LUT indexes */
3452 int val, sign; /* temp values */
3453 int first_block = 1;
3455 int skipped, fourmv;
3456 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3458 mquant = v->pq; /* lossy initialization */
3460 if (v->mv_type_is_raw)
3461 fourmv = get_bits1(gb);
3463 fourmv = v->mv_type_mb_plane[mb_pos];
3465 skipped = get_bits1(gb);
3467 skipped = v->s.mbskip_table[mb_pos];
3469 if (!fourmv) { /* 1MV mode */
3471 GET_MVDATA(dmv_x, dmv_y);
3474 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3475 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3477 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3478 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3480 /* FIXME Set DC val for inter block ? */
3481 if (s->mb_intra && !mb_has_coeffs) {
3483 s->ac_pred = get_bits1(gb);
3485 } else if (mb_has_coeffs) {
3487 s->ac_pred = get_bits1(gb);
3488 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3494 s->current_picture.qscale_table[mb_pos] = mquant;
3496 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3497 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3498 VC1_TTMB_VLC_BITS, 2);
3499 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3501 for (i = 0; i < 6; i++) {
3502 s->dc_val[0][s->block_index[i]] = 0;
3504 val = ((cbp >> (5 - i)) & 1);
3505 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3506 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3508 /* check if prediction blocks A and C are available */
3509 v->a_avail = v->c_avail = 0;
3510 if (i == 2 || i == 3 || !s->first_slice_line)
3511 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3512 if (i == 1 || i == 3 || s->mb_x)
3513 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3515 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3516 (i & 4) ? v->codingset2 : v->codingset);
3517 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3519 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3521 for (j = 0; j < 64; j++)
3522 s->block[i][j] <<= 1;
3523 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3524 if (v->pq >= 9 && v->overlap) {
3526 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3528 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3530 block_cbp |= 0xF << (i << 2);
3531 block_intra |= 1 << i;
3533 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3534 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3535 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3536 block_cbp |= pat << (i << 2);
3537 if (!v->ttmbf && ttmb < 8)
3544 for (i = 0; i < 6; i++) {
3545 v->mb_type[0][s->block_index[i]] = 0;
3546 s->dc_val[0][s->block_index[i]] = 0;
3548 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3549 s->current_picture.qscale_table[mb_pos] = 0;
3550 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3553 } else { // 4MV mode
3554 if (!skipped /* unskipped MB */) {
3555 int intra_count = 0, coded_inter = 0;
3556 int is_intra[6], is_coded[6];
3558 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3559 for (i = 0; i < 6; i++) {
3560 val = ((cbp >> (5 - i)) & 1);
3561 s->dc_val[0][s->block_index[i]] = 0;
3568 GET_MVDATA(dmv_x, dmv_y);
3570 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3572 vc1_mc_4mv_luma(v, i, 0);
3573 intra_count += s->mb_intra;
3574 is_intra[i] = s->mb_intra;
3575 is_coded[i] = mb_has_coeffs;
3578 is_intra[i] = (intra_count >= 3);
3582 vc1_mc_4mv_chroma(v, 0);
3583 v->mb_type[0][s->block_index[i]] = is_intra[i];
3585 coded_inter = !is_intra[i] & is_coded[i];
3587 // if there are no coded blocks then don't do anything more
3589 if (!intra_count && !coded_inter)
3592 s->current_picture.qscale_table[mb_pos] = mquant;
3593 /* test if block is intra and has pred */
3596 for (i = 0; i < 6; i++)
3598 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3599 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3605 s->ac_pred = get_bits1(gb);
3609 if (!v->ttmbf && coded_inter)
3610 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3611 for (i = 0; i < 6; i++) {
3613 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3614 s->mb_intra = is_intra[i];
3616 /* check if prediction blocks A and C are available */
3617 v->a_avail = v->c_avail = 0;
3618 if (i == 2 || i == 3 || !s->first_slice_line)
3619 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3620 if (i == 1 || i == 3 || s->mb_x)
3621 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3623 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3624 (i & 4) ? v->codingset2 : v->codingset);
3625 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3627 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3629 for (j = 0; j < 64; j++)
3630 s->block[i][j] <<= 1;
3631 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3632 (i & 4) ? s->uvlinesize : s->linesize);
3633 if (v->pq >= 9 && v->overlap) {
3635 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3637 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3639 block_cbp |= 0xF << (i << 2);
3640 block_intra |= 1 << i;
3641 } else if (is_coded[i]) {
3642 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3643 first_block, s->dest[dst_idx] + off,
3644 (i & 4) ? s->uvlinesize : s->linesize,
3645 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3647 block_cbp |= pat << (i << 2);
3648 if (!v->ttmbf && ttmb < 8)
3653 } else { // skipped MB
3655 s->current_picture.qscale_table[mb_pos] = 0;
3656 for (i = 0; i < 6; i++) {
3657 v->mb_type[0][s->block_index[i]] = 0;
3658 s->dc_val[0][s->block_index[i]] = 0;
3660 for (i = 0; i < 4; i++) {
3661 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3662 vc1_mc_4mv_luma(v, i, 0);
3664 vc1_mc_4mv_chroma(v, 0);
3665 s->current_picture.qscale_table[mb_pos] = 0;
3669 v->cbp[s->mb_x] = block_cbp;
3670 v->ttblk[s->mb_x] = block_tt;
3671 v->is_intra[s->mb_x] = block_intra;
3676 /* Decode one macroblock in an interlaced frame p picture */
3678 static int vc1_decode_p_mb_intfr(VC1Context *v)
3680 MpegEncContext *s = &v->s;
3681 GetBitContext *gb = &s->gb;
3683 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3684 int cbp = 0; /* cbp decoding stuff */
3685 int mqdiff, mquant; /* MB quantization */
3686 int ttmb = v->ttfrm; /* MB Transform type */
3688 int mb_has_coeffs = 1; /* last_flag */
3689 int dmv_x, dmv_y; /* Differential MV components */
3690 int val; /* temp value */
3691 int first_block = 1;
3693 int skipped, fourmv = 0, twomv = 0;
3694 int block_cbp = 0, pat, block_tt = 0;
3695 int idx_mbmode = 0, mvbp;
3696 int stride_y, fieldtx;
3698 mquant = v->pq; /* Loosy initialization */
3701 skipped = get_bits1(gb);
3703 skipped = v->s.mbskip_table[mb_pos];
3705 if (v->fourmvswitch)
3706 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3708 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3709 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3710 /* store the motion vector type in a flag (useful later) */
3711 case MV_PMODE_INTFR_4MV:
3713 v->blk_mv_type[s->block_index[0]] = 0;
3714 v->blk_mv_type[s->block_index[1]] = 0;
3715 v->blk_mv_type[s->block_index[2]] = 0;
3716 v->blk_mv_type[s->block_index[3]] = 0;
3718 case MV_PMODE_INTFR_4MV_FIELD:
3720 v->blk_mv_type[s->block_index[0]] = 1;
3721 v->blk_mv_type[s->block_index[1]] = 1;
3722 v->blk_mv_type[s->block_index[2]] = 1;
3723 v->blk_mv_type[s->block_index[3]] = 1;
3725 case MV_PMODE_INTFR_2MV_FIELD:
3727 v->blk_mv_type[s->block_index[0]] = 1;
3728 v->blk_mv_type[s->block_index[1]] = 1;
3729 v->blk_mv_type[s->block_index[2]] = 1;
3730 v->blk_mv_type[s->block_index[3]] = 1;
3732 case MV_PMODE_INTFR_1MV:
3733 v->blk_mv_type[s->block_index[0]] = 0;
3734 v->blk_mv_type[s->block_index[1]] = 0;
3735 v->blk_mv_type[s->block_index[2]] = 0;
3736 v->blk_mv_type[s->block_index[3]] = 0;
3739 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3740 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3741 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3742 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3743 s->mb_intra = v->is_intra[s->mb_x] = 1;
3744 for (i = 0; i < 6; i++)
3745 v->mb_type[0][s->block_index[i]] = 1;
3746 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3747 mb_has_coeffs = get_bits1(gb);
3749 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3750 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3752 s->current_picture.qscale_table[mb_pos] = mquant;
3753 /* Set DC scale - y and c use the same (not sure if necessary here) */
3754 s->y_dc_scale = s->y_dc_scale_table[mquant];
3755 s->c_dc_scale = s->c_dc_scale_table[mquant];
3757 for (i = 0; i < 6; i++) {
3758 s->dc_val[0][s->block_index[i]] = 0;
3760 val = ((cbp >> (5 - i)) & 1);
3761 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3762 v->a_avail = v->c_avail = 0;
3763 if (i == 2 || i == 3 || !s->first_slice_line)
3764 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3765 if (i == 1 || i == 3 || s->mb_x)
3766 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3768 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3769 (i & 4) ? v->codingset2 : v->codingset);
3770 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3771 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3773 stride_y = s->linesize << fieldtx;
3774 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3776 stride_y = s->uvlinesize;
3779 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3783 } else { // inter MB
3784 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3786 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3787 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3788 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3790 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3791 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3792 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3795 s->mb_intra = v->is_intra[s->mb_x] = 0;
3796 for (i = 0; i < 6; i++)
3797 v->mb_type[0][s->block_index[i]] = 0;
3798 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3799 /* for all motion vector read MVDATA and motion compensate each block */
3803 for (i = 0; i < 6; i++) {
3806 val = ((mvbp >> (3 - i)) & 1);
3808 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3810 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3811 vc1_mc_4mv_luma(v, i, 0);
3812 } else if (i == 4) {
3813 vc1_mc_4mv_chroma4(v);
3820 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3822 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3823 vc1_mc_4mv_luma(v, 0, 0);
3824 vc1_mc_4mv_luma(v, 1, 0);
3827 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3829 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3830 vc1_mc_4mv_luma(v, 2, 0);
3831 vc1_mc_4mv_luma(v, 3, 0);
3832 vc1_mc_4mv_chroma4(v);
3834 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3837 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3839 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3843 GET_MQUANT(); // p. 227
3844 s->current_picture.qscale_table[mb_pos] = mquant;
3845 if (!v->ttmbf && cbp)
3846 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3847 for (i = 0; i < 6; i++) {
3848 s->dc_val[0][s->block_index[i]] = 0;
3850 val = ((cbp >> (5 - i)) & 1);
3852 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3854 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3856 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3857 first_block, s->dest[dst_idx] + off,
3858 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3859 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3860 block_cbp |= pat << (i << 2);
3861 if (!v->ttmbf && ttmb < 8)
3868 s->mb_intra = v->is_intra[s->mb_x] = 0;
3869 for (i = 0; i < 6; i++) {
3870 v->mb_type[0][s->block_index[i]] = 0;
3871 s->dc_val[0][s->block_index[i]] = 0;
3873 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3874 s->current_picture.qscale_table[mb_pos] = 0;
3875 v->blk_mv_type[s->block_index[0]] = 0;
3876 v->blk_mv_type[s->block_index[1]] = 0;
3877 v->blk_mv_type[s->block_index[2]] = 0;
3878 v->blk_mv_type[s->block_index[3]] = 0;
3879 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3882 if (s->mb_x == s->mb_width - 1)
3883 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3887 static int vc1_decode_p_mb_intfi(VC1Context *v)
3889 MpegEncContext *s = &v->s;
3890 GetBitContext *gb = &s->gb;
3892 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3893 int cbp = 0; /* cbp decoding stuff */
3894 int mqdiff, mquant; /* MB quantization */
3895 int ttmb = v->ttfrm; /* MB Transform type */
3897 int mb_has_coeffs = 1; /* last_flag */
3898 int dmv_x, dmv_y; /* Differential MV components */
3899 int val; /* temp values */
3900 int first_block = 1;
3903 int block_cbp = 0, pat, block_tt = 0;
3906 mquant = v->pq; /* Loosy initialization */
3908 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3909 if (idx_mbmode <= 1) { // intra MB
3910 s->mb_intra = v->is_intra[s->mb_x] = 1;
3911 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3912 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3913 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3915 s->current_picture.qscale_table[mb_pos] = mquant;
3916 /* Set DC scale - y and c use the same (not sure if necessary here) */
3917 s->y_dc_scale = s->y_dc_scale_table[mquant];
3918 s->c_dc_scale = s->c_dc_scale_table[mquant];
3919 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3920 mb_has_coeffs = idx_mbmode & 1;
3922 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3924 for (i = 0; i < 6; i++) {
3925 s->dc_val[0][s->block_index[i]] = 0;
3926 v->mb_type[0][s->block_index[i]] = 1;
3928 val = ((cbp >> (5 - i)) & 1);
3929 v->a_avail = v->c_avail = 0;
3930 if (i == 2 || i == 3 || !s->first_slice_line)
3931 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3932 if (i == 1 || i == 3 || s->mb_x)
3933 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3935 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3936 (i & 4) ? v->codingset2 : v->codingset);
3937 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3939 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3940 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3941 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
3942 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
3943 // TODO: loop filter
3946 s->mb_intra = v->is_intra[s->mb_x] = 0;
3947 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3948 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3949 if (idx_mbmode <= 5) { // 1-MV
3950 dmv_x = dmv_y = pred_flag = 0;
3951 if (idx_mbmode & 1) {
3952 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3954 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3956 mb_has_coeffs = !(idx_mbmode & 2);
3958 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3959 for (i = 0; i < 6; i++) {
3961 dmv_x = dmv_y = pred_flag = 0;
3962 val = ((v->fourmvbp >> (3 - i)) & 1);
3964 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3966 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3967 vc1_mc_4mv_luma(v, i, 0);
3969 vc1_mc_4mv_chroma(v, 0);
3971 mb_has_coeffs = idx_mbmode & 1;
3974 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3978 s->current_picture.qscale_table[mb_pos] = mquant;
3979 if (!v->ttmbf && cbp) {
3980 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3983 for (i = 0; i < 6; i++) {
3984 s->dc_val[0][s->block_index[i]] = 0;
3986 val = ((cbp >> (5 - i)) & 1);
3987 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
3988 if (v->cur_field_type)
3989 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
3991 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3992 first_block, s->dest[dst_idx] + off,
3993 (i & 4) ? s->uvlinesize : s->linesize,
3994 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3996 block_cbp |= pat << (i << 2);
3997 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4002 if (s->mb_x == s->mb_width - 1)
4003 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4007 /** Decode one B-frame MB (in Main profile)
4009 static void vc1_decode_b_mb(VC1Context *v)
4011 MpegEncContext *s = &v->s;
4012 GetBitContext *gb = &s->gb;
4014 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4015 int cbp = 0; /* cbp decoding stuff */
4016 int mqdiff, mquant; /* MB quantization */
4017 int ttmb = v->ttfrm; /* MB Transform type */
4018 int mb_has_coeffs = 0; /* last_flag */
4019 int index, index1; /* LUT indexes */
4020 int val, sign; /* temp values */
4021 int first_block = 1;
4023 int skipped, direct;
4024 int dmv_x[2], dmv_y[2];
4025 int bmvtype = BMV_TYPE_BACKWARD;
4027 mquant = v->pq; /* lossy initialization */
4031 direct = get_bits1(gb);
4033 direct = v->direct_mb_plane[mb_pos];
4035 skipped = get_bits1(gb);
4037 skipped = v->s.mbskip_table[mb_pos];
4039 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4040 for (i = 0; i < 6; i++) {
4041 v->mb_type[0][s->block_index[i]] = 0;
4042 s->dc_val[0][s->block_index[i]] = 0;
4044 s->current_picture.qscale_table[mb_pos] = 0;
4048 GET_MVDATA(dmv_x[0], dmv_y[0]);
4049 dmv_x[1] = dmv_x[0];
4050 dmv_y[1] = dmv_y[0];
4052 if (skipped || !s->mb_intra) {
4053 bmvtype = decode012(gb);
4056 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4059 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4062 bmvtype = BMV_TYPE_INTERPOLATED;
4063 dmv_x[0] = dmv_y[0] = 0;
4067 for (i = 0; i < 6; i++)
4068 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4072 bmvtype = BMV_TYPE_INTERPOLATED;
4073 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4074 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4078 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4081 s->current_picture.qscale_table[mb_pos] = mquant;
4083 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4084 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4085 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4086 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4088 if (!mb_has_coeffs && !s->mb_intra) {
4089 /* no coded blocks - effectively skipped */
4090 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4091 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4094 if (s->mb_intra && !mb_has_coeffs) {
4096 s->current_picture.qscale_table[mb_pos] = mquant;
4097 s->ac_pred = get_bits1(gb);
4099 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4101 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4102 GET_MVDATA(dmv_x[0], dmv_y[0]);
4103 if (!mb_has_coeffs) {
4104 /* interpolated skipped block */
4105 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4106 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4110 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4112 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4115 s->ac_pred = get_bits1(gb);
4116 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4118 s->current_picture.qscale_table[mb_pos] = mquant;
4119 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4120 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4124 for (i = 0; i < 6; i++) {
4125 s->dc_val[0][s->block_index[i]] = 0;
4127 val = ((cbp >> (5 - i)) & 1);
4128 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4129 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4131 /* check if prediction blocks A and C are available */
4132 v->a_avail = v->c_avail = 0;
4133 if (i == 2 || i == 3 || !s->first_slice_line)
4134 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4135 if (i == 1 || i == 3 || s->mb_x)
4136 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4138 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4139 (i & 4) ? v->codingset2 : v->codingset);
4140 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4142 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4144 for (j = 0; j < 64; j++)
4145 s->block[i][j] <<= 1;
4146 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4148 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4149 first_block, s->dest[dst_idx] + off,
4150 (i & 4) ? s->uvlinesize : s->linesize,
4151 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4152 if (!v->ttmbf && ttmb < 8)
4159 /** Decode one B-frame MB (in interlaced field B picture)
4161 static void vc1_decode_b_mb_intfi(VC1Context *v)
4163 MpegEncContext *s = &v->s;
4164 GetBitContext *gb = &s->gb;
4166 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4167 int cbp = 0; /* cbp decoding stuff */
4168 int mqdiff, mquant; /* MB quantization */
4169 int ttmb = v->ttfrm; /* MB Transform type */
4170 int mb_has_coeffs = 0; /* last_flag */
4171 int val; /* temp value */
4172 int first_block = 1;
4175 int dmv_x[2], dmv_y[2], pred_flag[2];
4176 int bmvtype = BMV_TYPE_BACKWARD;
4177 int idx_mbmode, interpmvp;
4179 mquant = v->pq; /* Loosy initialization */
4182 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4183 if (idx_mbmode <= 1) { // intra MB
4184 s->mb_intra = v->is_intra[s->mb_x] = 1;
4185 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4186 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4187 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4189 s->current_picture.qscale_table[mb_pos] = mquant;
4190 /* Set DC scale - y and c use the same (not sure if necessary here) */
4191 s->y_dc_scale = s->y_dc_scale_table[mquant];
4192 s->c_dc_scale = s->c_dc_scale_table[mquant];
4193 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4194 mb_has_coeffs = idx_mbmode & 1;
4196 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4198 for (i = 0; i < 6; i++) {
4199 s->dc_val[0][s->block_index[i]] = 0;
4201 val = ((cbp >> (5 - i)) & 1);
4202 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4203 v->a_avail = v->c_avail = 0;
4204 if (i == 2 || i == 3 || !s->first_slice_line)
4205 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4206 if (i == 1 || i == 3 || s->mb_x)
4207 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4209 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4210 (i & 4) ? v->codingset2 : v->codingset);
4211 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4213 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4215 for (j = 0; j < 64; j++)
4216 s->block[i][j] <<= 1;
4217 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4218 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4219 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4220 // TODO: yet to perform loop filter
4223 s->mb_intra = v->is_intra[s->mb_x] = 0;
4224 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4225 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4227 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4229 fwd = v->forward_mb_plane[mb_pos];
4230 if (idx_mbmode <= 5) { // 1-MV
4231 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4232 pred_flag[0] = pred_flag[1] = 0;
4234 bmvtype = BMV_TYPE_FORWARD;
4236 bmvtype = decode012(gb);
4239 bmvtype = BMV_TYPE_BACKWARD;
4242 bmvtype = BMV_TYPE_DIRECT;
4245 bmvtype = BMV_TYPE_INTERPOLATED;
4246 interpmvp = get_bits1(gb);
4249 v->bmvtype = bmvtype;
4250 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4251 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4253 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4254 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4256 if (bmvtype == BMV_TYPE_DIRECT) {
4257 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4258 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4260 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4261 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4262 mb_has_coeffs = !(idx_mbmode & 2);
4265 bmvtype = BMV_TYPE_FORWARD;
4266 v->bmvtype = bmvtype;
4267 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4268 for (i = 0; i < 6; i++) {
4270 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4271 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4272 val = ((v->fourmvbp >> (3 - i)) & 1);
4274 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4275 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4276 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4278 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4279 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4281 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4283 mb_has_coeffs = idx_mbmode & 1;
4286 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4290 s->current_picture.qscale_table[mb_pos] = mquant;
4291 if (!v->ttmbf && cbp) {
4292 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4295 for (i = 0; i < 6; i++) {
4296 s->dc_val[0][s->block_index[i]] = 0;
4298 val = ((cbp >> (5 - i)) & 1);
4299 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4300 if (v->cur_field_type)
4301 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4303 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4304 first_block, s->dest[dst_idx] + off,
4305 (i & 4) ? s->uvlinesize : s->linesize,
4306 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4307 if (!v->ttmbf && ttmb < 8)
4315 /** Decode blocks of I-frame
4317 static void vc1_decode_i_blocks(VC1Context *v)
4320 MpegEncContext *s = &v->s;
4325 /* select codingmode used for VLC tables selection */
4326 switch (v->y_ac_table_index) {
4328 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4331 v->codingset = CS_HIGH_MOT_INTRA;
4334 v->codingset = CS_MID_RATE_INTRA;
4338 switch (v->c_ac_table_index) {
4340 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4343 v->codingset2 = CS_HIGH_MOT_INTER;
4346 v->codingset2 = CS_MID_RATE_INTER;
4350 /* Set DC scale - y and c use the same */
4351 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4352 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4355 s->mb_x = s->mb_y = 0;
4357 s->first_slice_line = 1;
4358 for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4360 ff_init_block_index(s);
4361 for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4363 ff_update_block_index(s);
4364 dst[0] = s->dest[0];
4365 dst[1] = dst[0] + 8;
4366 dst[2] = s->dest[0] + s->linesize * 8;
4367 dst[3] = dst[2] + 8;
4368 dst[4] = s->dest[1];
4369 dst[5] = s->dest[2];
4370 s->dsp.clear_blocks(s->block[0]);
4371 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4372 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4373 s->current_picture.qscale_table[mb_pos] = v->pq;
4374 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4375 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4377 // do actual MB decoding and displaying
4378 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4379 v->s.ac_pred = get_bits1(&v->s.gb);
4381 for (k = 0; k < 6; k++) {
4382 val = ((cbp >> (5 - k)) & 1);
4385 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4389 cbp |= val << (5 - k);
4391 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4393 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4395 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4396 if (v->pq >= 9 && v->overlap) {
4398 for (j = 0; j < 64; j++)
4399 s->block[k][j] <<= 1;
4400 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4403 for (j = 0; j < 64; j++)
4404 s->block[k][j] = (s->block[k][j] - 64) << 1;
4405 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4409 if (v->pq >= 9 && v->overlap) {
4411 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4412 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4413 if (!(s->flags & CODEC_FLAG_GRAY)) {
4414 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4415 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4418 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4419 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4420 if (!s->first_slice_line) {
4421 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4422 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4423 if (!(s->flags & CODEC_FLAG_GRAY)) {
4424 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4425 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4428 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4429 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4431 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4433 if (get_bits_count(&s->gb) > v->bits) {
4434 ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4435 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4436 get_bits_count(&s->gb), v->bits);
4440 if (!v->s.loop_filter)
4441 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4443 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4445 s->first_slice_line = 0;
4447 if (v->s.loop_filter)
4448 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4450 /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4451 * profile, these only differ are when decoding MSS2 rectangles. */
4452 ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4455 /** Decode blocks of I-frame for advanced profile
4457 static void vc1_decode_i_blocks_adv(VC1Context *v)
4460 MpegEncContext *s = &v->s;
4466 GetBitContext *gb = &s->gb;
4468 /* select codingmode used for VLC tables selection */
4469 switch (v->y_ac_table_index) {
4471 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4474 v->codingset = CS_HIGH_MOT_INTRA;
4477 v->codingset = CS_MID_RATE_INTRA;
4481 switch (v->c_ac_table_index) {
4483 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4486 v->codingset2 = CS_HIGH_MOT_INTER;
4489 v->codingset2 = CS_MID_RATE_INTER;
4494 s->mb_x = s->mb_y = 0;
4496 s->first_slice_line = 1;
4497 s->mb_y = s->start_mb_y;
4498 if (s->start_mb_y) {
4500 ff_init_block_index(s);
4501 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4502 (1 + s->b8_stride) * sizeof(*s->coded_block));
4504 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4506 ff_init_block_index(s);
4507 for (;s->mb_x < s->mb_width; s->mb_x++) {
4508 int16_t (*block)[64] = v->block[v->cur_blk_idx];
4509 ff_update_block_index(s);
4510 s->dsp.clear_blocks(block[0]);
4511 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4512 s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4513 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4514 s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4516 // do actual MB decoding and displaying
4517 if (v->fieldtx_is_raw)
4518 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4519 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4520 if ( v->acpred_is_raw)
4521 v->s.ac_pred = get_bits1(&v->s.gb);
4523 v->s.ac_pred = v->acpred_plane[mb_pos];
4525 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4526 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4530 s->current_picture.qscale_table[mb_pos] = mquant;
4531 /* Set DC scale - y and c use the same */
4532 s->y_dc_scale = s->y_dc_scale_table[mquant];
4533 s->c_dc_scale = s->c_dc_scale_table[mquant];
4535 for (k = 0; k < 6; k++) {
4536 val = ((cbp >> (5 - k)) & 1);
4539 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4543 cbp |= val << (5 - k);
4545 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4546 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4548 vc1_decode_i_block_adv(v, block[k], k, val,
4549 (k < 4) ? v->codingset : v->codingset2, mquant);
4551 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4553 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4556 vc1_smooth_overlap_filter_iblk(v);
4557 vc1_put_signed_blocks_clamped(v);
4558 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4560 if (get_bits_count(&s->gb) > v->bits) {
4561 // TODO: may need modification to handle slice coding
4562 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4563 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4564 get_bits_count(&s->gb), v->bits);
4568 if (!v->s.loop_filter)
4569 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4571 ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4572 s->first_slice_line = 0;
4575 /* raw bottom MB row */
4577 ff_init_block_index(s);
4578 for (;s->mb_x < s->mb_width; s->mb_x++) {
4579 ff_update_block_index(s);
4580 vc1_put_signed_blocks_clamped(v);
4581 if (v->s.loop_filter)
4582 vc1_loop_filter_iblk_delayed(v, v->pq);
4584 if (v->s.loop_filter)
4585 ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4586 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4587 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4590 static void vc1_decode_p_blocks(VC1Context *v)
4592 MpegEncContext *s = &v->s;
4593 int apply_loop_filter;
4595 /* select codingmode used for VLC tables selection */
4596 switch (v->c_ac_table_index) {
4598 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4601 v->codingset = CS_HIGH_MOT_INTRA;
4604 v->codingset = CS_MID_RATE_INTRA;
4608 switch (v->c_ac_table_index) {
4610 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4613 v->codingset2 = CS_HIGH_MOT_INTER;
4616 v->codingset2 = CS_MID_RATE_INTER;
4620 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
4621 s->first_slice_line = 1;
4622 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
4623 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4625 ff_init_block_index(s);
4626 for (; s->mb_x < s->mb_width; s->mb_x++) {
4627 ff_update_block_index(s);
4629 if (v->fcm == ILACE_FIELD)
4630 vc1_decode_p_mb_intfi(v);
4631 else if (v->fcm == ILACE_FRAME)
4632 vc1_decode_p_mb_intfr(v);
4633 else vc1_decode_p_mb(v);
4634 if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == PROGRESSIVE)
4635 vc1_apply_p_loop_filter(v);
4636 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4637 // TODO: may need modification to handle slice coding
4638 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4639 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4640 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4644 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
4645 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
4646 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4647 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
4648 if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4649 s->first_slice_line = 0;
4651 if (apply_loop_filter) {
4653 ff_init_block_index(s);
4654 for (; s->mb_x < s->mb_width; s->mb_x++) {
4655 ff_update_block_index(s);
4656 vc1_apply_p_loop_filter(v);
4659 if (s->end_mb_y >= s->start_mb_y)
4660 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4661 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4662 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4665 static void vc1_decode_b_blocks(VC1Context *v)
4667 MpegEncContext *s = &v->s;
4669 /* select codingmode used for VLC tables selection */
4670 switch (v->c_ac_table_index) {
4672 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4675 v->codingset = CS_HIGH_MOT_INTRA;
4678 v->codingset = CS_MID_RATE_INTRA;
4682 switch (v->c_ac_table_index) {
4684 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4687 v->codingset2 = CS_HIGH_MOT_INTER;
4690 v->codingset2 = CS_MID_RATE_INTER;
4694 s->first_slice_line = 1;
4695 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4697 ff_init_block_index(s);
4698 for (; s->mb_x < s->mb_width; s->mb_x++) {
4699 ff_update_block_index(s);
4701 if (v->fcm == ILACE_FIELD)
4702 vc1_decode_b_mb_intfi(v);
4705 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4706 // TODO: may need modification to handle slice coding
4707 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4708 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4709 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4712 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4714 if (!v->s.loop_filter)
4715 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4717 ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4718 s->first_slice_line = 0;
4720 if (v->s.loop_filter)
4721 ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4722 ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4723 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4726 static void vc1_decode_skip_blocks(VC1Context *v)
4728 MpegEncContext *s = &v->s;
4730 ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
4731 s->first_slice_line = 1;
4732 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4734 ff_init_block_index(s);
4735 ff_update_block_index(s);
4736 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4737 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4738 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4739 ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4740 s->first_slice_line = 0;
4742 s->pict_type = AV_PICTURE_TYPE_P;
4745 void ff_vc1_decode_blocks(VC1Context *v)
4748 v->s.esc3_level_length = 0;
4750 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
4753 v->left_blk_idx = -1;
4754 v->topleft_blk_idx = 1;
4756 switch (v->s.pict_type) {
4757 case AV_PICTURE_TYPE_I:
4758 if (v->profile == PROFILE_ADVANCED)
4759 vc1_decode_i_blocks_adv(v);
4761 vc1_decode_i_blocks(v);
4763 case AV_PICTURE_TYPE_P:
4764 if (v->p_frame_skipped)
4765 vc1_decode_skip_blocks(v);
4767 vc1_decode_p_blocks(v);
4769 case AV_PICTURE_TYPE_B:
4771 if (v->profile == PROFILE_ADVANCED)
4772 vc1_decode_i_blocks_adv(v);
4774 vc1_decode_i_blocks(v);
4776 vc1_decode_b_blocks(v);
4782 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
4786 * Transform coefficients for both sprites in 16.16 fixed point format,
4787 * in the order they appear in the bitstream:
4789 * rotation 1 (unused)
4791 * rotation 2 (unused)
4798 int effect_type, effect_flag;
4799 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
4800 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
4803 static inline int get_fp_val(GetBitContext* gb)
4805 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
4808 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
4812 switch (get_bits(gb, 2)) {
4815 c[2] = get_fp_val(gb);
4819 c[0] = c[4] = get_fp_val(gb);
4820 c[2] = get_fp_val(gb);
4823 c[0] = get_fp_val(gb);
4824 c[2] = get_fp_val(gb);
4825 c[4] = get_fp_val(gb);
4828 c[0] = get_fp_val(gb);
4829 c[1] = get_fp_val(gb);
4830 c[2] = get_fp_val(gb);
4831 c[3] = get_fp_val(gb);
4832 c[4] = get_fp_val(gb);
4835 c[5] = get_fp_val(gb);
4837 c[6] = get_fp_val(gb);
4842 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
4844 AVCodecContext *avctx = v->s.avctx;
4847 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4848 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
4849 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
4850 avpriv_request_sample(avctx, "Non-zero rotation coefficients");
4851 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
4852 for (i = 0; i < 7; i++)
4853 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
4854 sd->coefs[sprite][i] / (1<<16),
4855 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
4856 av_log(avctx, AV_LOG_DEBUG, "\n");
4860 if (sd->effect_type = get_bits_long(gb, 30)) {
4861 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
4863 vc1_sprite_parse_transform(gb, sd->effect_params1);
4866 vc1_sprite_parse_transform(gb, sd->effect_params1);
4867 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
4870 for (i = 0; i < sd->effect_pcount1; i++)
4871 sd->effect_params1[i] = get_fp_val(gb);
4873 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
4874 // effect 13 is simple alpha blending and matches the opacity above
4875 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
4876 for (i = 0; i < sd->effect_pcount1; i++)
4877 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4878 sd->effect_params1[i] / (1 << 16),
4879 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
4880 av_log(avctx, AV_LOG_DEBUG, "\n");
4883 sd->effect_pcount2 = get_bits(gb, 16);
4884 if (sd->effect_pcount2 > 10) {
4885 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
4887 } else if (sd->effect_pcount2) {
4889 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
4890 while (++i < sd->effect_pcount2) {
4891 sd->effect_params2[i] = get_fp_val(gb);
4892 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4893 sd->effect_params2[i] / (1 << 16),
4894 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
4896 av_log(avctx, AV_LOG_DEBUG, "\n");
4899 if (sd->effect_flag = get_bits1(gb))
4900 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4902 if (get_bits_count(gb) >= gb->size_in_bits +
4903 (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
4904 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4905 if (get_bits_count(gb) < gb->size_in_bits - 8)
4906 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4909 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
4911 int i, plane, row, sprite;
4912 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
4913 uint8_t* src_h[2][2];
4914 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
4916 MpegEncContext *s = &v->s;
4918 for (i = 0; i < 2; i++) {
4919 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
4920 xadv[i] = sd->coefs[i][0];
4921 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
4922 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
4924 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
4925 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
4927 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
4929 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
4930 int width = v->output_width>>!!plane;
4932 for (row = 0; row < v->output_height>>!!plane; row++) {
4933 uint8_t *dst = v->sprite_output_frame.data[plane] +
4934 v->sprite_output_frame.linesize[plane] * row;
4936 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4937 uint8_t *iplane = s->current_picture.f.data[plane];
4938 int iline = s->current_picture.f.linesize[plane];
4939 int ycoord = yoff[sprite] + yadv[sprite] * row;
4940 int yline = ycoord >> 16;
4942 ysub[sprite] = ycoord & 0xFFFF;
4944 iplane = s->last_picture.f.data[plane];
4945 iline = s->last_picture.f.linesize[plane];
4947 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
4948 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4949 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
4951 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
4953 if (sr_cache[sprite][0] != yline) {
4954 if (sr_cache[sprite][1] == yline) {
4955 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
4956 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
4958 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
4959 sr_cache[sprite][0] = yline;
4962 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4963 v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
4964 iplane + next_line, xoff[sprite],
4965 xadv[sprite], width);
4966 sr_cache[sprite][1] = yline + 1;
4968 src_h[sprite][0] = v->sr_rows[sprite][0];
4969 src_h[sprite][1] = v->sr_rows[sprite][1];
4973 if (!v->two_sprites) {
4975 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
4977 memcpy(dst, src_h[0][0], width);
4980 if (ysub[0] && ysub[1]) {
4981 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
4982 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
4983 } else if (ysub[0]) {
4984 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
4985 src_h[1][0], alpha, width);
4986 } else if (ysub[1]) {
4987 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
4988 src_h[0][0], (1<<16)-1-alpha, width);
4990 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
4996 for (i = 0; i < 2; i++) {
5006 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5008 MpegEncContext *s = &v->s;
5009 AVCodecContext *avctx = s->avctx;
5012 vc1_parse_sprites(v, gb, &sd);
5014 if (!s->current_picture.f.data[0]) {
5015 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5019 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5020 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5024 av_frame_unref(&v->sprite_output_frame);
5025 if (ff_get_buffer(avctx, &v->sprite_output_frame, 0) < 0) {
5026 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5030 vc1_draw_sprites(v, &sd);
5035 static void vc1_sprite_flush(AVCodecContext *avctx)
5037 VC1Context *v = avctx->priv_data;
5038 MpegEncContext *s = &v->s;
5039 AVFrame *f = &s->current_picture.f;
5042 /* Windows Media Image codecs have a convergence interval of two keyframes.
5043 Since we can't enforce it, clear to black the missing sprite. This is
5044 wrong but it looks better than doing nothing. */
5047 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5048 for (i = 0; i < v->sprite_height>>!!plane; i++)
5049 memset(f->data[plane] + i * f->linesize[plane],
5050 plane ? 128 : 0, f->linesize[plane]);
5055 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5057 MpegEncContext *s = &v->s;
5060 /* Allocate mb bitplanes */
5061 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5062 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5063 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5064 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5065 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5066 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5068 v->n_allocated_blks = s->mb_width + 2;
5069 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5070 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5071 v->cbp = v->cbp_base + s->mb_stride;
5072 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5073 v->ttblk = v->ttblk_base + s->mb_stride;
5074 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5075 v->is_intra = v->is_intra_base + s->mb_stride;
5076 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5077 v->luma_mv = v->luma_mv_base + s->mb_stride;
5079 /* allocate block type info in that way so it could be used with s->block_index[] */
5080 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5081 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5082 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5083 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5085 /* allocate memory to store block level MV info */
5086 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5087 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5088 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5089 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5090 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5091 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5092 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
5093 v->mv_f_last[1] = v->mv_f_last[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5094 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5095 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5096 v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5098 /* Init coded blocks info */
5099 if (v->profile == PROFILE_ADVANCED) {
5100 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5102 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5106 ff_intrax8_common_init(&v->x8,s);
5108 if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5109 for (i = 0; i < 4; i++)
5110 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5113 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5114 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5121 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5124 for (i = 0; i < 64; i++) {
5125 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5126 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5127 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5128 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5129 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5130 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5136 /** Initialize a VC1/WMV3 decoder
5137 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5138 * @todo TODO: Decypher remaining bits in extra_data
5140 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5142 VC1Context *v = avctx->priv_data;
5143 MpegEncContext *s = &v->s;
5146 /* save the container output size for WMImage */
5147 v->output_width = avctx->width;
5148 v->output_height = avctx->height;
5150 if (!avctx->extradata_size || !avctx->extradata)
5152 if (!(avctx->flags & CODEC_FLAG_GRAY))
5153 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5155 avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5156 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5158 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5159 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5161 if (ff_vc1_init_common(v) < 0)
5163 ff_h264chroma_init(&v->h264chroma, 8);
5164 ff_vc1dsp_init(&v->vc1dsp);
5166 if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5169 // looks like WMV3 has a sequence header stored in the extradata
5170 // advanced sequence header may be before the first frame
5171 // the last byte of the extradata is a version number, 1 for the
5172 // samples we can decode
5174 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5176 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5179 count = avctx->extradata_size*8 - get_bits_count(&gb);
5181 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5182 count, get_bits(&gb, count));
5183 } else if (count < 0) {
5184 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5186 } else { // VC1/WVC1/WVP2
5187 const uint8_t *start = avctx->extradata;
5188 uint8_t *end = avctx->extradata + avctx->extradata_size;
5189 const uint8_t *next;
5190 int size, buf2_size;
5191 uint8_t *buf2 = NULL;
5192 int seq_initialized = 0, ep_initialized = 0;
5194 if (avctx->extradata_size < 16) {
5195 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5199 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5200 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5202 for (; next < end; start = next) {
5203 next = find_next_marker(start + 4, end);
5204 size = next - start - 4;
5207 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5208 init_get_bits(&gb, buf2, buf2_size * 8);
5209 switch (AV_RB32(start)) {
5210 case VC1_CODE_SEQHDR:
5211 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5215 seq_initialized = 1;
5217 case VC1_CODE_ENTRYPOINT:
5218 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5227 if (!seq_initialized || !ep_initialized) {
5228 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5231 v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5234 avctx->profile = v->profile;
5235 if (v->profile == PROFILE_ADVANCED)
5236 avctx->level = v->level;
5238 avctx->has_b_frames = !!avctx->max_b_frames;
5240 s->mb_width = (avctx->coded_width + 15) >> 4;
5241 s->mb_height = (avctx->coded_height + 15) >> 4;
5243 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5244 ff_vc1_init_transposed_scantables(v);
5246 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5251 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5252 v->sprite_width = avctx->coded_width;
5253 v->sprite_height = avctx->coded_height;
5255 avctx->coded_width = avctx->width = v->output_width;
5256 avctx->coded_height = avctx->height = v->output_height;
5258 // prevent 16.16 overflows
5259 if (v->sprite_width > 1 << 14 ||
5260 v->sprite_height > 1 << 14 ||
5261 v->output_width > 1 << 14 ||
5262 v->output_height > 1 << 14) return -1;
5267 /** Close a VC1/WMV3 decoder
5268 * @warning Initial try at using MpegEncContext stuff
5270 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5272 VC1Context *v = avctx->priv_data;
5275 av_frame_unref(&v->sprite_output_frame);
5277 for (i = 0; i < 4; i++)
5278 av_freep(&v->sr_rows[i >> 1][i & 1]);
5279 av_freep(&v->hrd_rate);
5280 av_freep(&v->hrd_buffer);
5281 ff_MPV_common_end(&v->s);
5282 av_freep(&v->mv_type_mb_plane);
5283 av_freep(&v->direct_mb_plane);
5284 av_freep(&v->forward_mb_plane);
5285 av_freep(&v->fieldtx_plane);
5286 av_freep(&v->acpred_plane);
5287 av_freep(&v->over_flags_plane);
5288 av_freep(&v->mb_type_base);
5289 av_freep(&v->blk_mv_type_base);
5290 av_freep(&v->mv_f_base);
5291 av_freep(&v->mv_f_last_base);
5292 av_freep(&v->mv_f_next_base);
5293 av_freep(&v->block);
5294 av_freep(&v->cbp_base);
5295 av_freep(&v->ttblk_base);
5296 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5297 av_freep(&v->luma_mv_base);
5298 ff_intrax8_common_end(&v->x8);
5303 /** Decode a VC1/WMV3 frame
5304 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5306 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5307 int *got_frame, AVPacket *avpkt)
5309 const uint8_t *buf = avpkt->data;
5310 int buf_size = avpkt->size, n_slices = 0, i, ret;
5311 VC1Context *v = avctx->priv_data;
5312 MpegEncContext *s = &v->s;
5313 AVFrame *pict = data;
5314 uint8_t *buf2 = NULL;
5315 const uint8_t *buf_start = buf;
5316 int mb_height, n_slices1;
5321 } *slices = NULL, *tmp;
5323 /* no supplementary picture */
5324 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5325 /* special case for last picture */
5326 if (s->low_delay == 0 && s->next_picture_ptr) {
5327 if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
5329 s->next_picture_ptr = NULL;
5337 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5338 if (v->profile < PROFILE_ADVANCED)
5339 avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5341 avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5344 //for advanced profile we may need to parse and unescape data
5345 if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5347 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5349 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5350 const uint8_t *start, *end, *next;
5354 for (start = buf, end = buf + buf_size; next < end; start = next) {
5355 next = find_next_marker(start + 4, end);
5356 size = next - start - 4;
5357 if (size <= 0) continue;
5358 switch (AV_RB32(start)) {
5359 case VC1_CODE_FRAME:
5360 if (avctx->hwaccel ||
5361 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5363 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5365 case VC1_CODE_FIELD: {
5367 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5371 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5372 if (!slices[n_slices].buf)
5374 buf_size3 = vc1_unescape_buffer(start + 4, size,
5375 slices[n_slices].buf);
5376 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5378 /* assuming that the field marker is at the exact middle,
5379 hope it's correct */
5380 slices[n_slices].mby_start = s->mb_height >> 1;
5381 n_slices1 = n_slices - 1; // index of the last slice of the first field
5385 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5386 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5387 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5388 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5390 case VC1_CODE_SLICE: {
5392 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5396 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5397 if (!slices[n_slices].buf)
5399 buf_size3 = vc1_unescape_buffer(start + 4, size,
5400 slices[n_slices].buf);
5401 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5403 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5409 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5410 const uint8_t *divider;
5413 divider = find_next_marker(buf, buf + buf_size);
5414 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5415 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5417 } else { // found field marker, unescape second field
5418 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5422 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5423 if (!slices[n_slices].buf)
5425 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5426 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5428 slices[n_slices].mby_start = s->mb_height >> 1;
5429 n_slices1 = n_slices - 1;
5432 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5434 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5436 init_get_bits(&s->gb, buf2, buf_size2*8);
5438 init_get_bits(&s->gb, buf, buf_size*8);
5440 if (v->res_sprite) {
5441 v->new_sprite = !get_bits1(&s->gb);
5442 v->two_sprites = get_bits1(&s->gb);
5443 /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5444 we're using the sprite compositor. These are intentionally kept separate
5445 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5446 the vc1 one for WVP2 */
5447 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5448 if (v->new_sprite) {
5449 // switch AVCodecContext parameters to those of the sprites
5450 avctx->width = avctx->coded_width = v->sprite_width;
5451 avctx->height = avctx->coded_height = v->sprite_height;
5458 if (s->context_initialized &&
5459 (s->width != avctx->coded_width ||
5460 s->height != avctx->coded_height)) {
5461 ff_vc1_decode_end(avctx);
5464 if (!s->context_initialized) {
5465 if (ff_msmpeg4_decode_init(avctx) < 0 || ff_vc1_decode_init_alloc_tables(v) < 0)
5468 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5470 if (v->profile == PROFILE_ADVANCED) {
5471 s->h_edge_pos = avctx->coded_width;
5472 s->v_edge_pos = avctx->coded_height;
5476 /* We need to set current_picture_ptr before reading the header,
5477 * otherwise we cannot store anything in there. */
5478 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5479 int i = ff_find_unused_picture(s, 0);
5482 s->current_picture_ptr = &s->picture[i];
5485 // do parse frame header
5486 v->pic_header_flag = 0;
5487 if (v->profile < PROFILE_ADVANCED) {
5488 if (ff_vc1_parse_frame_header(v, &s->gb) == -1) {
5492 if (ff_vc1_parse_frame_header_adv(v, &s->gb) == -1) {
5497 if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5498 && s->pict_type != AV_PICTURE_TYPE_I) {
5499 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5503 // process pulldown flags
5504 s->current_picture_ptr->f.repeat_pict = 0;
5505 // Pulldown flags are only valid when 'broadcast' has been set.
5506 // So ticks_per_frame will be 2
5509 s->current_picture_ptr->f.repeat_pict = 1;
5510 } else if (v->rptfrm) {
5512 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5515 // for skipping the frame
5516 s->current_picture.f.pict_type = s->pict_type;
5517 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5519 /* skip B-frames if we don't have reference frames */
5520 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
5523 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5524 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5525 avctx->skip_frame >= AVDISCARD_ALL) {
5529 if (s->next_p_frame_damaged) {
5530 if (s->pict_type == AV_PICTURE_TYPE_B)
5533 s->next_p_frame_damaged = 0;
5536 if (ff_MPV_frame_start(s, avctx) < 0) {
5540 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5541 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5543 if ((CONFIG_VC1_VDPAU_DECODER)
5544 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5545 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5546 else if (avctx->hwaccel) {
5547 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
5549 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5551 if (avctx->hwaccel->end_frame(avctx) < 0)
5554 ff_mpeg_er_frame_start(s);
5556 v->bits = buf_size * 8;
5557 v->end_mb_x = s->mb_width;
5558 if (v->field_mode) {
5560 s->current_picture.f.linesize[0] <<= 1;
5561 s->current_picture.f.linesize[1] <<= 1;
5562 s->current_picture.f.linesize[2] <<= 1;
5564 s->uvlinesize <<= 1;
5565 tmp[0] = v->mv_f_last[0];
5566 tmp[1] = v->mv_f_last[1];
5567 v->mv_f_last[0] = v->mv_f_next[0];
5568 v->mv_f_last[1] = v->mv_f_next[1];
5569 v->mv_f_next[0] = v->mv_f[0];
5570 v->mv_f_next[1] = v->mv_f[1];
5571 v->mv_f[0] = tmp[0];
5572 v->mv_f[1] = tmp[1];
5574 mb_height = s->mb_height >> v->field_mode;
5575 for (i = 0; i <= n_slices; i++) {
5576 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5577 if (v->field_mode <= 0) {
5578 av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
5579 "picture boundary (%d >= %d)\n", i,
5580 slices[i - 1].mby_start, mb_height);
5583 v->second_field = 1;
5584 v->blocks_off = s->mb_width * s->mb_height << 1;
5585 v->mb_off = s->mb_stride * s->mb_height >> 1;
5587 v->second_field = 0;
5592 v->pic_header_flag = 0;
5593 if (v->field_mode && i == n_slices1 + 2) {
5594 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5595 av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
5598 } else if (get_bits1(&s->gb)) {
5599 v->pic_header_flag = 1;
5600 if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5601 av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
5606 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5607 if (!v->field_mode || v->second_field)
5608 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5610 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5611 ff_vc1_decode_blocks(v);
5613 s->gb = slices[i].gb;
5615 if (v->field_mode) {
5616 v->second_field = 0;
5617 if (s->pict_type == AV_PICTURE_TYPE_B) {
5618 memcpy(v->mv_f_base, v->mv_f_next_base,
5619 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5621 s->current_picture.f.linesize[0] >>= 1;
5622 s->current_picture.f.linesize[1] >>= 1;
5623 s->current_picture.f.linesize[2] >>= 1;
5625 s->uvlinesize >>= 1;
5627 av_dlog(s->avctx, "Consumed %i/%i bits\n",
5628 get_bits_count(&s->gb), s->gb.size_in_bits);
5629 // if (get_bits_count(&s->gb) > buf_size * 8)
5631 ff_er_frame_end(&s->er);
5634 ff_MPV_frame_end(s);
5636 if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5638 avctx->width = avctx->coded_width = v->output_width;
5639 avctx->height = avctx->coded_height = v->output_height;
5640 if (avctx->skip_frame >= AVDISCARD_NONREF)
5642 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5643 if (vc1_decode_sprites(v, &s->gb))
5646 if ((ret = av_frame_ref(pict, &v->sprite_output_frame)) < 0)
5650 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5651 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
5653 ff_print_debug_info(s, s->current_picture_ptr);
5654 } else if (s->last_picture_ptr != NULL) {
5655 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
5657 ff_print_debug_info(s, s->last_picture_ptr);
5659 if (s->last_picture_ptr || s->low_delay) {
5666 for (i = 0; i < n_slices; i++)
5667 av_free(slices[i].buf);
5673 for (i = 0; i < n_slices; i++)
5674 av_free(slices[i].buf);
5680 static const AVProfile profiles[] = {
5681 { FF_PROFILE_VC1_SIMPLE, "Simple" },
5682 { FF_PROFILE_VC1_MAIN, "Main" },
5683 { FF_PROFILE_VC1_COMPLEX, "Complex" },
5684 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5685 { FF_PROFILE_UNKNOWN },
5688 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
5690 AV_PIX_FMT_DXVA2_VLD,
5693 AV_PIX_FMT_VAAPI_VLD,
5702 AVCodec ff_vc1_decoder = {
5704 .type = AVMEDIA_TYPE_VIDEO,
5705 .id = AV_CODEC_ID_VC1,
5706 .priv_data_size = sizeof(VC1Context),
5707 .init = vc1_decode_init,
5708 .close = ff_vc1_decode_end,
5709 .decode = vc1_decode_frame,
5710 .flush = ff_mpeg_flush,
5711 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5712 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5713 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
5714 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5717 #if CONFIG_WMV3_DECODER
5718 AVCodec ff_wmv3_decoder = {
5720 .type = AVMEDIA_TYPE_VIDEO,
5721 .id = AV_CODEC_ID_WMV3,
5722 .priv_data_size = sizeof(VC1Context),
5723 .init = vc1_decode_init,
5724 .close = ff_vc1_decode_end,
5725 .decode = vc1_decode_frame,
5726 .flush = ff_mpeg_flush,
5727 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5728 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5729 .pix_fmts = vc1_hwaccel_pixfmt_list_420,
5730 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5734 #if CONFIG_WMV3_VDPAU_DECODER
5735 AVCodec ff_wmv3_vdpau_decoder = {
5736 .name = "wmv3_vdpau",
5737 .type = AVMEDIA_TYPE_VIDEO,
5738 .id = AV_CODEC_ID_WMV3,
5739 .priv_data_size = sizeof(VC1Context),
5740 .init = vc1_decode_init,
5741 .close = ff_vc1_decode_end,
5742 .decode = vc1_decode_frame,
5743 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5744 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5745 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
5746 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5750 #if CONFIG_VC1_VDPAU_DECODER
5751 AVCodec ff_vc1_vdpau_decoder = {
5752 .name = "vc1_vdpau",
5753 .type = AVMEDIA_TYPE_VIDEO,
5754 .id = AV_CODEC_ID_VC1,
5755 .priv_data_size = sizeof(VC1Context),
5756 .init = vc1_decode_init,
5757 .close = ff_vc1_decode_end,
5758 .decode = vc1_decode_frame,
5759 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5760 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5761 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
5762 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5766 #if CONFIG_WMV3IMAGE_DECODER
5767 AVCodec ff_wmv3image_decoder = {
5768 .name = "wmv3image",
5769 .type = AVMEDIA_TYPE_VIDEO,
5770 .id = AV_CODEC_ID_WMV3IMAGE,
5771 .priv_data_size = sizeof(VC1Context),
5772 .init = vc1_decode_init,
5773 .close = ff_vc1_decode_end,
5774 .decode = vc1_decode_frame,
5775 .capabilities = CODEC_CAP_DR1,
5776 .flush = vc1_sprite_flush,
5777 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5778 .pix_fmts = ff_pixfmt_list_420
5782 #if CONFIG_VC1IMAGE_DECODER
5783 AVCodec ff_vc1image_decoder = {
5785 .type = AVMEDIA_TYPE_VIDEO,
5786 .id = AV_CODEC_ID_VC1IMAGE,
5787 .priv_data_size = sizeof(VC1Context),
5788 .init = vc1_decode_init,
5789 .close = ff_vc1_decode_end,
5790 .decode = vc1_decode_frame,
5791 .capabilities = CODEC_CAP_DR1,
5792 .flush = vc1_sprite_flush,
5793 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5794 .pix_fmts = ff_pixfmt_list_420