2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
32 #include "mpegvideo.h"
36 #include "vc1acdata.h"
37 #include "msmpeg4data.h"
39 #include "simple_idct.h"
41 #include "vdpau_internal.h"
46 #define MB_INTRA_VLC_BITS 9
50 // offset tables for interlaced picture MVDATA decoding
51 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
52 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
54 /***********************************************************************/
56 * @name VC-1 Bitplane decoding
74 /** @} */ //imode defines
77 /** @} */ //Bitplane group
79 static void vc1_put_signed_blocks_clamped(VC1Context *v)
81 MpegEncContext *s = &v->s;
82 int topleft_mb_pos, top_mb_pos;
83 int stride_y, fieldtx;
86 /* The put pixels loop is always one MB row behind the decoding loop,
87 * because we can only put pixels when overlap filtering is done, and
88 * for filtering of the bottom edge of a MB, we need the next MB row
90 * Within the row, the put pixels loop is also one MB col behind the
91 * decoding loop. The reason for this is again, because for filtering
92 * of the right MB edge, we need the next MB present. */
93 if (!s->first_slice_line) {
95 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
96 fieldtx = v->fieldtx_plane[topleft_mb_pos];
97 stride_y = s->linesize << fieldtx;
98 v_dist = (16 - fieldtx) >> (fieldtx == 0);
99 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
100 s->dest[0] - 16 * s->linesize - 16,
102 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
103 s->dest[0] - 16 * s->linesize - 8,
105 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
106 s->dest[0] - v_dist * s->linesize - 16,
108 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
109 s->dest[0] - v_dist * s->linesize - 8,
111 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
112 s->dest[1] - 8 * s->uvlinesize - 8,
114 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
115 s->dest[2] - 8 * s->uvlinesize - 8,
118 if (s->mb_x == s->mb_width - 1) {
119 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
120 fieldtx = v->fieldtx_plane[top_mb_pos];
121 stride_y = s->linesize << fieldtx;
122 v_dist = fieldtx ? 15 : 8;
123 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
124 s->dest[0] - 16 * s->linesize,
126 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
127 s->dest[0] - 16 * s->linesize + 8,
129 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
130 s->dest[0] - v_dist * s->linesize,
132 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
133 s->dest[0] - v_dist * s->linesize + 8,
135 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
136 s->dest[1] - 8 * s->uvlinesize,
138 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
139 s->dest[2] - 8 * s->uvlinesize,
144 #define inc_blk_idx(idx) do { \
146 if (idx >= v->n_allocated_blks) \
150 inc_blk_idx(v->topleft_blk_idx);
151 inc_blk_idx(v->top_blk_idx);
152 inc_blk_idx(v->left_blk_idx);
153 inc_blk_idx(v->cur_blk_idx);
156 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
158 MpegEncContext *s = &v->s;
160 if (!s->first_slice_line) {
161 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
163 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
164 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
165 for (j = 0; j < 2; j++) {
166 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
168 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
171 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
173 if (s->mb_y == s->end_mb_y - 1) {
175 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
176 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
177 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
179 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
183 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
185 MpegEncContext *s = &v->s;
188 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
189 * means it runs two rows/cols behind the decoding loop. */
190 if (!s->first_slice_line) {
192 if (s->mb_y >= s->start_mb_y + 2) {
193 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
196 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
197 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
198 for (j = 0; j < 2; j++) {
199 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
201 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
205 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
208 if (s->mb_x == s->mb_width - 1) {
209 if (s->mb_y >= s->start_mb_y + 2) {
210 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
213 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
214 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
215 for (j = 0; j < 2; j++) {
216 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
218 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
222 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
225 if (s->mb_y == s->end_mb_y) {
228 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
229 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
231 for (j = 0; j < 2; j++) {
232 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
237 if (s->mb_x == s->mb_width - 1) {
239 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
240 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
242 for (j = 0; j < 2; j++) {
243 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
251 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
253 MpegEncContext *s = &v->s;
256 if (v->condover == CONDOVER_NONE)
259 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
261 /* Within a MB, the horizontal overlap always runs before the vertical.
262 * To accomplish that, we run the H on left and internal borders of the
263 * currently decoded MB. Then, we wait for the next overlap iteration
264 * to do H overlap on the right edge of this MB, before moving over and
265 * running the V overlap. Therefore, the V overlap makes us trail by one
266 * MB col and the H overlap filter makes us trail by one MB row. This
267 * is reflected in the time at which we run the put_pixels loop. */
268 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
269 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
270 v->over_flags_plane[mb_pos - 1])) {
271 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
272 v->block[v->cur_blk_idx][0]);
273 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
274 v->block[v->cur_blk_idx][2]);
275 if (!(s->flags & CODEC_FLAG_GRAY)) {
276 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
277 v->block[v->cur_blk_idx][4]);
278 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
279 v->block[v->cur_blk_idx][5]);
282 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
283 v->block[v->cur_blk_idx][1]);
284 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
285 v->block[v->cur_blk_idx][3]);
287 if (s->mb_x == s->mb_width - 1) {
288 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
289 v->over_flags_plane[mb_pos - s->mb_stride])) {
290 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
291 v->block[v->cur_blk_idx][0]);
292 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
293 v->block[v->cur_blk_idx][1]);
294 if (!(s->flags & CODEC_FLAG_GRAY)) {
295 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
296 v->block[v->cur_blk_idx][4]);
297 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
298 v->block[v->cur_blk_idx][5]);
301 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
302 v->block[v->cur_blk_idx][2]);
303 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
304 v->block[v->cur_blk_idx][3]);
307 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
308 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
309 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
310 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
311 v->block[v->left_blk_idx][0]);
312 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
313 v->block[v->left_blk_idx][1]);
314 if (!(s->flags & CODEC_FLAG_GRAY)) {
315 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
316 v->block[v->left_blk_idx][4]);
317 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
318 v->block[v->left_blk_idx][5]);
321 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
322 v->block[v->left_blk_idx][2]);
323 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
324 v->block[v->left_blk_idx][3]);
328 /** Do motion compensation over 1 macroblock
329 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
331 static void vc1_mc_1mv(VC1Context *v, int dir)
333 MpegEncContext *s = &v->s;
334 DSPContext *dsp = &v->s.dsp;
335 uint8_t *srcY, *srcU, *srcV;
336 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
338 int v_edge_pos = s->v_edge_pos >> v->field_mode;
340 if ((!v->field_mode ||
341 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
342 !v->s.last_picture.f.data[0])
345 mx = s->mv[dir][0][0];
346 my = s->mv[dir][0][1];
348 // store motion vectors for further use in B frames
349 if (s->pict_type == AV_PICTURE_TYPE_P) {
350 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
351 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
354 uvmx = (mx + ((mx & 3) == 3)) >> 1;
355 uvmy = (my + ((my & 3) == 3)) >> 1;
356 v->luma_mv[s->mb_x][0] = uvmx;
357 v->luma_mv[s->mb_x][1] = uvmy;
360 v->cur_field_type != v->ref_field_type[dir]) {
361 my = my - 2 + 4 * v->cur_field_type;
362 uvmy = uvmy - 2 + 4 * v->cur_field_type;
365 // fastuvmc shall be ignored for interlaced frame picture
366 if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
367 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
368 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
370 if (v->field_mode) { // interlaced field picture
372 if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
373 srcY = s->current_picture.f.data[0];
374 srcU = s->current_picture.f.data[1];
375 srcV = s->current_picture.f.data[2];
377 srcY = s->last_picture.f.data[0];
378 srcU = s->last_picture.f.data[1];
379 srcV = s->last_picture.f.data[2];
382 srcY = s->next_picture.f.data[0];
383 srcU = s->next_picture.f.data[1];
384 srcV = s->next_picture.f.data[2];
388 srcY = s->last_picture.f.data[0];
389 srcU = s->last_picture.f.data[1];
390 srcV = s->last_picture.f.data[2];
392 srcY = s->next_picture.f.data[0];
393 srcU = s->next_picture.f.data[1];
394 srcV = s->next_picture.f.data[2];
398 src_x = s->mb_x * 16 + (mx >> 2);
399 src_y = s->mb_y * 16 + (my >> 2);
400 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
401 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
403 if (v->profile != PROFILE_ADVANCED) {
404 src_x = av_clip( src_x, -16, s->mb_width * 16);
405 src_y = av_clip( src_y, -16, s->mb_height * 16);
406 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
407 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
409 src_x = av_clip( src_x, -17, s->avctx->coded_width);
410 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
411 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
412 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
415 srcY += src_y * s->linesize + src_x;
416 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
417 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
419 if (v->field_mode && v->ref_field_type[dir]) {
420 srcY += s->current_picture_ptr->f.linesize[0];
421 srcU += s->current_picture_ptr->f.linesize[1];
422 srcV += s->current_picture_ptr->f.linesize[2];
425 /* for grayscale we should not try to read from unknown area */
426 if (s->flags & CODEC_FLAG_GRAY) {
427 srcU = s->edge_emu_buffer + 18 * s->linesize;
428 srcV = s->edge_emu_buffer + 18 * s->linesize;
431 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
432 || s->h_edge_pos < 22 || v_edge_pos < 22
433 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
434 || (unsigned)(src_y - s->mspel) > v_edge_pos - (my&3) - 16 - s->mspel * 3) {
435 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
437 srcY -= s->mspel * (1 + s->linesize);
438 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
439 17 + s->mspel * 2, 17 + s->mspel * 2,
440 src_x - s->mspel, src_y - s->mspel,
441 s->h_edge_pos, v_edge_pos);
442 srcY = s->edge_emu_buffer;
443 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
444 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
445 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
446 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
449 /* if we deal with range reduction we need to scale source blocks */
450 if (v->rangeredfrm) {
455 for (j = 0; j < 17 + s->mspel * 2; j++) {
456 for (i = 0; i < 17 + s->mspel * 2; i++)
457 src[i] = ((src[i] - 128) >> 1) + 128;
462 for (j = 0; j < 9; j++) {
463 for (i = 0; i < 9; i++) {
464 src[i] = ((src[i] - 128) >> 1) + 128;
465 src2[i] = ((src2[i] - 128) >> 1) + 128;
467 src += s->uvlinesize;
468 src2 += s->uvlinesize;
471 /* if we deal with intensity compensation we need to scale source blocks */
472 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
477 for (j = 0; j < 17 + s->mspel * 2; j++) {
478 for (i = 0; i < 17 + s->mspel * 2; i++)
479 src[i] = v->luty[src[i]];
484 for (j = 0; j < 9; j++) {
485 for (i = 0; i < 9; i++) {
486 src[i] = v->lutuv[src[i]];
487 src2[i] = v->lutuv[src2[i]];
489 src += s->uvlinesize;
490 src2 += s->uvlinesize;
493 srcY += s->mspel * (1 + s->linesize);
496 if (v->field_mode && v->second_field) {
497 off = s->current_picture_ptr->f.linesize[0];
498 off_uv = s->current_picture_ptr->f.linesize[1];
504 dxy = ((my & 3) << 2) | (mx & 3);
505 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
506 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
507 srcY += s->linesize * 8;
508 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
509 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
510 } else { // hpel mc - always used for luma
511 dxy = (my & 2) | ((mx & 2) >> 1);
513 dsp->put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
515 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
518 if (s->flags & CODEC_FLAG_GRAY) return;
519 /* Chroma MC always uses qpel bilinear */
520 uvmx = (uvmx & 3) << 1;
521 uvmy = (uvmy & 3) << 1;
523 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
524 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
526 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
527 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
531 static inline int median4(int a, int b, int c, int d)
534 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
535 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
537 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
538 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
542 /** Do motion compensation for 4-MV macroblock - luminance block
544 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
546 MpegEncContext *s = &v->s;
547 DSPContext *dsp = &v->s.dsp;
549 int dxy, mx, my, src_x, src_y;
551 int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
552 int v_edge_pos = s->v_edge_pos >> v->field_mode;
554 if ((!v->field_mode ||
555 (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
556 !v->s.last_picture.f.data[0])
559 mx = s->mv[dir][n][0];
560 my = s->mv[dir][n][1];
564 if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field)
565 srcY = s->current_picture.f.data[0];
567 srcY = s->last_picture.f.data[0];
569 srcY = s->last_picture.f.data[0];
571 srcY = s->next_picture.f.data[0];
574 if (v->cur_field_type != v->ref_field_type[dir])
575 my = my - 2 + 4 * v->cur_field_type;
578 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
579 int same_count = 0, opp_count = 0, k;
580 int chosen_mv[2][4][2], f;
582 for (k = 0; k < 4; k++) {
583 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
584 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
585 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
589 f = opp_count > same_count;
590 switch (f ? opp_count : same_count) {
592 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
593 chosen_mv[f][2][0], chosen_mv[f][3][0]);
594 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
595 chosen_mv[f][2][1], chosen_mv[f][3][1]);
598 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
599 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
602 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
603 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
606 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
607 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
608 for (k = 0; k < 4; k++)
609 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
612 if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
614 int width = s->avctx->coded_width;
615 int height = s->avctx->coded_height >> 1;
616 qx = (s->mb_x * 16) + (mx >> 2);
617 qy = (s->mb_y * 8) + (my >> 3);
622 mx -= 4 * (qx - width);
625 else if (qy > height + 1)
626 my -= 8 * (qy - height - 1);
629 if ((v->fcm == ILACE_FRAME) && fieldmv)
630 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
632 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
633 if (v->field_mode && v->second_field)
634 off += s->current_picture_ptr->f.linesize[0];
636 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
638 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
640 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
642 if (v->profile != PROFILE_ADVANCED) {
643 src_x = av_clip(src_x, -16, s->mb_width * 16);
644 src_y = av_clip(src_y, -16, s->mb_height * 16);
646 src_x = av_clip(src_x, -17, s->avctx->coded_width);
647 if (v->fcm == ILACE_FRAME) {
649 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
651 src_y = av_clip(src_y, -18, s->avctx->coded_height);
653 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
657 srcY += src_y * s->linesize + src_x;
658 if (v->field_mode && v->ref_field_type[dir])
659 srcY += s->current_picture_ptr->f.linesize[0];
661 if (fieldmv && !(src_y & 1))
663 if (fieldmv && (src_y & 1) && src_y < 4)
665 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
666 || s->h_edge_pos < 13 || v_edge_pos < 23
667 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
668 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
669 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
670 /* check emulate edge stride and offset */
671 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
672 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
673 src_x - s->mspel, src_y - (s->mspel << fieldmv),
674 s->h_edge_pos, v_edge_pos);
675 srcY = s->edge_emu_buffer;
676 /* if we deal with range reduction we need to scale source blocks */
677 if (v->rangeredfrm) {
682 for (j = 0; j < 9 + s->mspel * 2; j++) {
683 for (i = 0; i < 9 + s->mspel * 2; i++)
684 src[i] = ((src[i] - 128) >> 1) + 128;
685 src += s->linesize << fieldmv;
688 /* if we deal with intensity compensation we need to scale source blocks */
689 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
694 for (j = 0; j < 9 + s->mspel * 2; j++) {
695 for (i = 0; i < 9 + s->mspel * 2; i++)
696 src[i] = v->luty[src[i]];
697 src += s->linesize << fieldmv;
700 srcY += s->mspel * (1 + (s->linesize << fieldmv));
704 dxy = ((my & 3) << 2) | (mx & 3);
705 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
706 } else { // hpel mc - always used for luma
707 dxy = (my & 2) | ((mx & 2) >> 1);
709 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
711 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
715 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
718 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
720 idx = ((a[3] != flag) << 3)
721 | ((a[2] != flag) << 2)
722 | ((a[1] != flag) << 1)
725 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
726 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
728 } else if (count[idx] == 1) {
731 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
732 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
735 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
736 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
739 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
740 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
743 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
744 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
747 } else if (count[idx] == 2) {
749 for (i = 0; i < 3; i++)
754 for (i = t1 + 1; i < 4; i++)
759 *tx = (mvx[t1] + mvx[t2]) / 2;
760 *ty = (mvy[t1] + mvy[t2]) / 2;
768 /** Do motion compensation for 4-MV macroblock - both chroma blocks
770 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
772 MpegEncContext *s = &v->s;
773 DSPContext *dsp = &v->s.dsp;
774 uint8_t *srcU, *srcV;
775 int uvmx, uvmy, uvsrc_x, uvsrc_y;
776 int k, tx = 0, ty = 0;
777 int mvx[4], mvy[4], intra[4], mv_f[4];
779 int chroma_ref_type = v->cur_field_type, off = 0;
780 int v_edge_pos = s->v_edge_pos >> v->field_mode;
782 if (!v->field_mode && !v->s.last_picture.f.data[0])
784 if (s->flags & CODEC_FLAG_GRAY)
787 for (k = 0; k < 4; k++) {
788 mvx[k] = s->mv[dir][k][0];
789 mvy[k] = s->mv[dir][k][1];
790 intra[k] = v->mb_type[0][s->block_index[k]];
792 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
795 /* calculate chroma MV vector from four luma MVs */
796 if (!v->field_mode || (v->field_mode && !v->numref)) {
797 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
799 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
800 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
801 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
802 return; //no need to do MC for intra blocks
806 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
808 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
810 chroma_ref_type = !v->cur_field_type;
812 if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
814 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
815 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
816 uvmx = (tx + ((tx & 3) == 3)) >> 1;
817 uvmy = (ty + ((ty & 3) == 3)) >> 1;
819 v->luma_mv[s->mb_x][0] = uvmx;
820 v->luma_mv[s->mb_x][1] = uvmy;
823 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
824 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
826 // Field conversion bias
827 if (v->cur_field_type != chroma_ref_type)
828 uvmy += 2 - 4 * chroma_ref_type;
830 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
831 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
833 if (v->profile != PROFILE_ADVANCED) {
834 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
835 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
837 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
838 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
843 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
844 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
845 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
847 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
848 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
851 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
852 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
855 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
856 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
860 if (chroma_ref_type) {
861 srcU += s->current_picture_ptr->f.linesize[1];
862 srcV += s->current_picture_ptr->f.linesize[2];
864 off = v->second_field ? s->current_picture_ptr->f.linesize[1] : 0;
867 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
868 || s->h_edge_pos < 18 || v_edge_pos < 18
869 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
870 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
871 s->dsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
872 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
873 s->h_edge_pos >> 1, v_edge_pos >> 1);
874 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
875 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
876 s->h_edge_pos >> 1, v_edge_pos >> 1);
877 srcU = s->edge_emu_buffer;
878 srcV = s->edge_emu_buffer + 16;
880 /* if we deal with range reduction we need to scale source blocks */
881 if (v->rangeredfrm) {
887 for (j = 0; j < 9; j++) {
888 for (i = 0; i < 9; i++) {
889 src[i] = ((src[i] - 128) >> 1) + 128;
890 src2[i] = ((src2[i] - 128) >> 1) + 128;
892 src += s->uvlinesize;
893 src2 += s->uvlinesize;
896 /* if we deal with intensity compensation we need to scale source blocks */
897 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
903 for (j = 0; j < 9; j++) {
904 for (i = 0; i < 9; i++) {
905 src[i] = v->lutuv[src[i]];
906 src2[i] = v->lutuv[src2[i]];
908 src += s->uvlinesize;
909 src2 += s->uvlinesize;
914 /* Chroma MC always uses qpel bilinear */
915 uvmx = (uvmx & 3) << 1;
916 uvmy = (uvmy & 3) << 1;
918 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
919 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
921 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
922 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
926 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
928 static void vc1_mc_4mv_chroma4(VC1Context *v)
930 MpegEncContext *s = &v->s;
931 DSPContext *dsp = &v->s.dsp;
932 uint8_t *srcU, *srcV;
933 int uvsrc_x, uvsrc_y;
934 int uvmx_field[4], uvmy_field[4];
936 int fieldmv = v->blk_mv_type[s->block_index[0]];
937 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
938 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
939 int v_edge_pos = s->v_edge_pos >> 1;
941 if (!v->s.last_picture.f.data[0])
943 if (s->flags & CODEC_FLAG_GRAY)
946 for (i = 0; i < 4; i++) {
948 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
951 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
953 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
956 for (i = 0; i < 4; i++) {
957 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
958 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
959 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
960 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
961 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
962 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
963 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
964 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
965 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
966 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
968 if (fieldmv && !(uvsrc_y & 1))
970 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
972 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
973 || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
974 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
975 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
976 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
977 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
978 s->h_edge_pos >> 1, v_edge_pos);
979 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
980 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
981 s->h_edge_pos >> 1, v_edge_pos);
982 srcU = s->edge_emu_buffer;
983 srcV = s->edge_emu_buffer + 16;
985 /* if we deal with intensity compensation we need to scale source blocks */
986 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
992 for (j = 0; j < 5; j++) {
993 for (i = 0; i < 5; i++) {
994 src[i] = v->lutuv[src[i]];
995 src2[i] = v->lutuv[src2[i]];
997 src += s->uvlinesize << 1;
998 src2 += s->uvlinesize << 1;
1003 dsp->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1004 dsp->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1006 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1007 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1012 /***********************************************************************/
1014 * @name VC-1 Block-level functions
1015 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1021 * @brief Get macroblock-level quantizer scale
1023 #define GET_MQUANT() \
1024 if (v->dquantfrm) { \
1026 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1027 if (v->dqbilevel) { \
1028 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1030 mqdiff = get_bits(gb, 3); \
1032 mquant = v->pq + mqdiff; \
1034 mquant = get_bits(gb, 5); \
1036 av_log(v->s.avctx,AV_LOG_ERROR, "zero mquant\n"); \
1041 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1042 edges = 1 << v->dqsbedge; \
1043 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1044 edges = (3 << v->dqsbedge) % 15; \
1045 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1047 if ((edges&1) && !s->mb_x) \
1048 mquant = v->altpq; \
1049 if ((edges&2) && s->first_slice_line) \
1050 mquant = v->altpq; \
1051 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1052 mquant = v->altpq; \
1053 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1054 mquant = v->altpq; \
1058 * @def GET_MVDATA(_dmv_x, _dmv_y)
1059 * @brief Get MV differentials
1060 * @see MVDATA decoding from 8.3.5.2, p(1)20
1061 * @param _dmv_x Horizontal differential for decoded MV
1062 * @param _dmv_y Vertical differential for decoded MV
1064 #define GET_MVDATA(_dmv_x, _dmv_y) \
1065 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1066 VC1_MV_DIFF_VLC_BITS, 2); \
1068 mb_has_coeffs = 1; \
1071 mb_has_coeffs = 0; \
1074 _dmv_x = _dmv_y = 0; \
1075 } else if (index == 35) { \
1076 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1077 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1078 } else if (index == 36) { \
1083 index1 = index % 6; \
1084 if (!s->quarter_sample && index1 == 5) val = 1; \
1086 if (size_table[index1] - val > 0) \
1087 val = get_bits(gb, size_table[index1] - val); \
1089 sign = 0 - (val&1); \
1090 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1092 index1 = index / 6; \
1093 if (!s->quarter_sample && index1 == 5) val = 1; \
1095 if (size_table[index1] - val > 0) \
1096 val = get_bits(gb, size_table[index1] - val); \
1098 sign = 0 - (val & 1); \
1099 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1102 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1103 int *dmv_y, int *pred_flag)
1106 int extend_x = 0, extend_y = 0;
1107 GetBitContext *gb = &v->s.gb;
1110 const int* offs_tab;
1113 bits = VC1_2REF_MVDATA_VLC_BITS;
1116 bits = VC1_1REF_MVDATA_VLC_BITS;
1119 switch (v->dmvrange) {
1127 extend_x = extend_y = 1;
1130 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1132 *dmv_x = get_bits(gb, v->k_x);
1133 *dmv_y = get_bits(gb, v->k_y);
1135 *pred_flag = *dmv_y & 1;
1136 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1141 offs_tab = offset_table2;
1143 offs_tab = offset_table1;
1144 index1 = (index + 1) % 9;
1146 val = get_bits(gb, index1 + extend_x);
1147 sign = 0 -(val & 1);
1148 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1152 offs_tab = offset_table2;
1154 offs_tab = offset_table1;
1155 index1 = (index + 1) / 9;
1156 if (index1 > v->numref) {
1157 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1158 sign = 0 - (val & 1);
1159 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1163 *pred_flag = index1 & 1;
1167 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1169 int scaledvalue, refdist;
1170 int scalesame1, scalesame2;
1171 int scalezone1_x, zone1offset_x;
1172 int table_index = dir ^ v->second_field;
1174 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1175 refdist = v->refdist;
1177 refdist = dir ? v->brfd : v->frfd;
1180 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1181 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1182 scalezone1_x = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1183 zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1188 if (FFABS(n) < scalezone1_x)
1189 scaledvalue = (n * scalesame1) >> 8;
1192 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1194 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1197 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1200 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1202 int scaledvalue, refdist;
1203 int scalesame1, scalesame2;
1204 int scalezone1_y, zone1offset_y;
1205 int table_index = dir ^ v->second_field;
1207 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1208 refdist = v->refdist;
1210 refdist = dir ? v->brfd : v->frfd;
1213 scalesame1 = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1214 scalesame2 = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1215 scalezone1_y = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1216 zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1221 if (FFABS(n) < scalezone1_y)
1222 scaledvalue = (n * scalesame1) >> 8;
1225 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1227 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1231 if (v->cur_field_type && !v->ref_field_type[dir])
1232 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1234 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1237 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1239 int scalezone1_x, zone1offset_x;
1240 int scaleopp1, scaleopp2, brfd;
1243 brfd = FFMIN(v->brfd, 3);
1244 scalezone1_x = ff_vc1_b_field_mvpred_scales[3][brfd];
1245 zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1246 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1247 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1252 if (FFABS(n) < scalezone1_x)
1253 scaledvalue = (n * scaleopp1) >> 8;
1256 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1258 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1261 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1264 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1266 int scalezone1_y, zone1offset_y;
1267 int scaleopp1, scaleopp2, brfd;
1270 brfd = FFMIN(v->brfd, 3);
1271 scalezone1_y = ff_vc1_b_field_mvpred_scales[4][brfd];
1272 zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1273 scaleopp1 = ff_vc1_b_field_mvpred_scales[1][brfd];
1274 scaleopp2 = ff_vc1_b_field_mvpred_scales[2][brfd];
1279 if (FFABS(n) < scalezone1_y)
1280 scaledvalue = (n * scaleopp1) >> 8;
1283 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1285 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1288 if (v->cur_field_type && !v->ref_field_type[dir]) {
1289 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1291 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1295 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1298 int brfd, scalesame;
1299 int hpel = 1 - v->s.quarter_sample;
1302 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1304 n = scaleforsame_y(v, i, n, dir) << hpel;
1306 n = scaleforsame_x(v, n, dir) << hpel;
1309 brfd = FFMIN(v->brfd, 3);
1310 scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1312 n = (n * scalesame >> 8) << hpel;
1316 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1319 int refdist, scaleopp;
1320 int hpel = 1 - v->s.quarter_sample;
1323 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1325 n = scaleforopp_y(v, n, dir) << hpel;
1327 n = scaleforopp_x(v, n) << hpel;
1330 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1331 refdist = FFMIN(v->refdist, 3);
1333 refdist = dir ? v->brfd : v->frfd;
1334 scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1336 n = (n * scaleopp >> 8) << hpel;
1340 /** Predict and set motion vector
1342 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1343 int mv1, int r_x, int r_y, uint8_t* is_intra,
1344 int pred_flag, int dir)
1346 MpegEncContext *s = &v->s;
1347 int xy, wrap, off = 0;
1351 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1352 int opposit, a_f, b_f, c_f;
1353 int16_t field_predA[2];
1354 int16_t field_predB[2];
1355 int16_t field_predC[2];
1356 int a_valid, b_valid, c_valid;
1357 int hybridmv_thresh, y_bias = 0;
1359 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1360 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1364 /* scale MV difference to be quad-pel */
1365 dmv_x <<= 1 - s->quarter_sample;
1366 dmv_y <<= 1 - s->quarter_sample;
1368 wrap = s->b8_stride;
1369 xy = s->block_index[n];
1372 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
1373 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
1374 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
1375 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
1376 if (mv1) { /* duplicate motion data for 1-MV block */
1377 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1378 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1379 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1380 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1381 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1382 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1383 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1384 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1385 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1386 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1387 s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1388 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1389 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1394 C = s->current_picture.f.motion_val[dir][xy - 1 + v->blocks_off];
1395 A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
1397 if (v->field_mode && mixedmv_pic)
1398 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1400 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1402 //in 4-MV mode different blocks have different B predictor position
1405 off = (s->mb_x > 0) ? -1 : 1;
1408 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1417 B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
1419 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1420 b_valid = a_valid && (s->mb_width > 1);
1421 c_valid = s->mb_x || (n == 1 || n == 3);
1422 if (v->field_mode) {
1423 a_valid = a_valid && !is_intra[xy - wrap];
1424 b_valid = b_valid && !is_intra[xy - wrap + off];
1425 c_valid = c_valid && !is_intra[xy - 1];
1429 a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1430 num_oppfield += a_f;
1431 num_samefield += 1 - a_f;
1432 field_predA[0] = A[0];
1433 field_predA[1] = A[1];
1435 field_predA[0] = field_predA[1] = 0;
1439 b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1440 num_oppfield += b_f;
1441 num_samefield += 1 - b_f;
1442 field_predB[0] = B[0];
1443 field_predB[1] = B[1];
1445 field_predB[0] = field_predB[1] = 0;
1449 c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1450 num_oppfield += c_f;
1451 num_samefield += 1 - c_f;
1452 field_predC[0] = C[0];
1453 field_predC[1] = C[1];
1455 field_predC[0] = field_predC[1] = 0;
1459 if (v->field_mode) {
1460 if (num_samefield <= num_oppfield)
1461 opposit = 1 - pred_flag;
1463 opposit = pred_flag;
1467 if (a_valid && !a_f) {
1468 field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1469 field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1471 if (b_valid && !b_f) {
1472 field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1473 field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1475 if (c_valid && !c_f) {
1476 field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1477 field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1479 v->mv_f[dir][xy + v->blocks_off] = 1;
1480 v->ref_field_type[dir] = !v->cur_field_type;
1482 if (a_valid && a_f) {
1483 field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1484 field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1486 if (b_valid && b_f) {
1487 field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1488 field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1490 if (c_valid && c_f) {
1491 field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1492 field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1494 v->mv_f[dir][xy + v->blocks_off] = 0;
1495 v->ref_field_type[dir] = v->cur_field_type;
1499 px = field_predA[0];
1500 py = field_predA[1];
1501 } else if (c_valid) {
1502 px = field_predC[0];
1503 py = field_predC[1];
1504 } else if (b_valid) {
1505 px = field_predB[0];
1506 py = field_predB[1];
1512 if (num_samefield + num_oppfield > 1) {
1513 px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1514 py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1517 /* Pullback MV as specified in 8.3.5.3.4 */
1518 if (!v->field_mode) {
1520 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1521 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1522 X = (s->mb_width << 6) - 4;
1523 Y = (s->mb_height << 6) - 4;
1525 if (qx + px < -60) px = -60 - qx;
1526 if (qy + py < -60) py = -60 - qy;
1528 if (qx + px < -28) px = -28 - qx;
1529 if (qy + py < -28) py = -28 - qy;
1531 if (qx + px > X) px = X - qx;
1532 if (qy + py > Y) py = Y - qy;
1535 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1536 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1537 hybridmv_thresh = 32;
1538 if (a_valid && c_valid) {
1539 if (is_intra[xy - wrap])
1540 sum = FFABS(px) + FFABS(py);
1542 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1543 if (sum > hybridmv_thresh) {
1544 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1545 px = field_predA[0];
1546 py = field_predA[1];
1548 px = field_predC[0];
1549 py = field_predC[1];
1552 if (is_intra[xy - 1])
1553 sum = FFABS(px) + FFABS(py);
1555 sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1556 if (sum > hybridmv_thresh) {
1557 if (get_bits1(&s->gb)) {
1558 px = field_predA[0];
1559 py = field_predA[1];
1561 px = field_predC[0];
1562 py = field_predC[1];
1569 if (v->field_mode && !s->quarter_sample) {
1573 if (v->field_mode && v->numref)
1575 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1577 /* store MV using signed modulus of MV range defined in 4.11 */
1578 s->mv[dir][n][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1579 s->mv[dir][n][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
1580 if (mv1) { /* duplicate motion data for 1-MV block */
1581 s->current_picture.f.motion_val[dir][xy + 1 + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1582 s->current_picture.f.motion_val[dir][xy + 1 + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1583 s->current_picture.f.motion_val[dir][xy + wrap + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1584 s->current_picture.f.motion_val[dir][xy + wrap + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1585 s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1586 s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1587 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1588 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];
1592 /** Predict and set motion vector for interlaced frame picture MBs
1594 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1595 int mvn, int r_x, int r_y, uint8_t* is_intra)
1597 MpegEncContext *s = &v->s;
1598 int xy, wrap, off = 0;
1599 int A[2], B[2], C[2];
1601 int a_valid = 0, b_valid = 0, c_valid = 0;
1602 int field_a, field_b, field_c; // 0: same, 1: opposit
1603 int total_valid, num_samefield, num_oppfield;
1604 int pos_c, pos_b, n_adj;
1606 wrap = s->b8_stride;
1607 xy = s->block_index[n];
1610 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
1611 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
1612 s->current_picture.f.motion_val[1][xy][0] = 0;
1613 s->current_picture.f.motion_val[1][xy][1] = 0;
1614 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1615 s->current_picture.f.motion_val[0][xy + 1][0] = 0;
1616 s->current_picture.f.motion_val[0][xy + 1][1] = 0;
1617 s->current_picture.f.motion_val[0][xy + wrap][0] = 0;
1618 s->current_picture.f.motion_val[0][xy + wrap][1] = 0;
1619 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
1620 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
1621 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1622 s->current_picture.f.motion_val[1][xy + 1][0] = 0;
1623 s->current_picture.f.motion_val[1][xy + 1][1] = 0;
1624 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1625 s->current_picture.f.motion_val[1][xy + wrap][1] = 0;
1626 s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
1627 s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
1632 off = ((n == 0) || (n == 1)) ? 1 : -1;
1634 if (s->mb_x || (n == 1) || (n == 3)) {
1635 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1636 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1637 A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
1638 A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
1640 } else { // current block has frame mv and cand. has field MV (so average)
1641 A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
1642 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1643 A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
1644 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1647 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1653 /* Predict B and C */
1654 B[0] = B[1] = C[0] = C[1] = 0;
1655 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1656 if (!s->first_slice_line) {
1657 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1660 pos_b = s->block_index[n_adj] - 2 * wrap;
1661 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1662 n_adj = (n & 2) | (n & 1);
1664 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1665 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1666 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1667 B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1668 B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1671 if (s->mb_width > 1) {
1672 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1675 pos_c = s->block_index[2] - 2 * wrap + 2;
1676 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1679 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1680 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1681 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1682 C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1683 C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1685 if (s->mb_x == s->mb_width - 1) {
1686 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1689 pos_c = s->block_index[3] - 2 * wrap - 2;
1690 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1693 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1694 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1695 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1696 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1697 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1706 pos_b = s->block_index[1];
1708 B[0] = s->current_picture.f.motion_val[0][pos_b][0];
1709 B[1] = s->current_picture.f.motion_val[0][pos_b][1];
1710 pos_c = s->block_index[0];
1712 C[0] = s->current_picture.f.motion_val[0][pos_c][0];
1713 C[1] = s->current_picture.f.motion_val[0][pos_c][1];
1716 total_valid = a_valid + b_valid + c_valid;
1717 // check if predictor A is out of bounds
1718 if (!s->mb_x && !(n == 1 || n == 3)) {
1721 // check if predictor B is out of bounds
1722 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1723 B[0] = B[1] = C[0] = C[1] = 0;
1725 if (!v->blk_mv_type[xy]) {
1726 if (s->mb_width == 1) {
1730 if (total_valid >= 2) {
1731 px = mid_pred(A[0], B[0], C[0]);
1732 py = mid_pred(A[1], B[1], C[1]);
1733 } else if (total_valid) {
1734 if (a_valid) { px = A[0]; py = A[1]; }
1735 if (b_valid) { px = B[0]; py = B[1]; }
1736 if (c_valid) { px = C[0]; py = C[1]; }
1742 field_a = (A[1] & 4) ? 1 : 0;
1746 field_b = (B[1] & 4) ? 1 : 0;
1750 field_c = (C[1] & 4) ? 1 : 0;
1754 num_oppfield = field_a + field_b + field_c;
1755 num_samefield = total_valid - num_oppfield;
1756 if (total_valid == 3) {
1757 if ((num_samefield == 3) || (num_oppfield == 3)) {
1758 px = mid_pred(A[0], B[0], C[0]);
1759 py = mid_pred(A[1], B[1], C[1]);
1760 } else if (num_samefield >= num_oppfield) {
1761 /* take one MV from same field set depending on priority
1762 the check for B may not be necessary */
1763 px = !field_a ? A[0] : B[0];
1764 py = !field_a ? A[1] : B[1];
1766 px = field_a ? A[0] : B[0];
1767 py = field_a ? A[1] : B[1];
1769 } else if (total_valid == 2) {
1770 if (num_samefield >= num_oppfield) {
1771 if (!field_a && a_valid) {
1774 } else if (!field_b && b_valid) {
1777 } else if (c_valid) {
1782 if (field_a && a_valid) {
1785 } else if (field_b && b_valid) {
1788 } else if (c_valid) {
1793 } else if (total_valid == 1) {
1794 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1795 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1800 /* store MV using signed modulus of MV range defined in 4.11 */
1801 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1802 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1803 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1804 s->current_picture.f.motion_val[0][xy + 1 ][0] = s->current_picture.f.motion_val[0][xy][0];
1805 s->current_picture.f.motion_val[0][xy + 1 ][1] = s->current_picture.f.motion_val[0][xy][1];
1806 s->current_picture.f.motion_val[0][xy + wrap ][0] = s->current_picture.f.motion_val[0][xy][0];
1807 s->current_picture.f.motion_val[0][xy + wrap ][1] = s->current_picture.f.motion_val[0][xy][1];
1808 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1809 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1810 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1811 s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1812 s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1813 s->mv[0][n + 1][0] = s->mv[0][n][0];
1814 s->mv[0][n + 1][1] = s->mv[0][n][1];
1818 /** Motion compensation for direct or interpolated blocks in B-frames
1820 static void vc1_interp_mc(VC1Context *v)
1822 MpegEncContext *s = &v->s;
1823 DSPContext *dsp = &v->s.dsp;
1824 uint8_t *srcY, *srcU, *srcV;
1825 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1827 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1829 if (!v->field_mode && !v->s.next_picture.f.data[0])
1832 mx = s->mv[1][0][0];
1833 my = s->mv[1][0][1];
1834 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1835 uvmy = (my + ((my & 3) == 3)) >> 1;
1836 if (v->field_mode) {
1837 if (v->cur_field_type != v->ref_field_type[1])
1838 my = my - 2 + 4 * v->cur_field_type;
1839 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1842 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1843 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1845 srcY = s->next_picture.f.data[0];
1846 srcU = s->next_picture.f.data[1];
1847 srcV = s->next_picture.f.data[2];
1849 src_x = s->mb_x * 16 + (mx >> 2);
1850 src_y = s->mb_y * 16 + (my >> 2);
1851 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1852 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1854 if (v->profile != PROFILE_ADVANCED) {
1855 src_x = av_clip( src_x, -16, s->mb_width * 16);
1856 src_y = av_clip( src_y, -16, s->mb_height * 16);
1857 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1858 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1860 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1861 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1862 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1863 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1866 srcY += src_y * s->linesize + src_x;
1867 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1868 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1870 if (v->field_mode && v->ref_field_type[1]) {
1871 srcY += s->current_picture_ptr->f.linesize[0];
1872 srcU += s->current_picture_ptr->f.linesize[1];
1873 srcV += s->current_picture_ptr->f.linesize[2];
1876 /* for grayscale we should not try to read from unknown area */
1877 if (s->flags & CODEC_FLAG_GRAY) {
1878 srcU = s->edge_emu_buffer + 18 * s->linesize;
1879 srcV = s->edge_emu_buffer + 18 * s->linesize;
1882 if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1883 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 16 - s->mspel * 3
1884 || (unsigned)(src_y - s->mspel) > v_edge_pos - (my & 3) - 16 - s->mspel * 3) {
1885 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1887 srcY -= s->mspel * (1 + s->linesize);
1888 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1889 17 + s->mspel * 2, 17 + s->mspel * 2,
1890 src_x - s->mspel, src_y - s->mspel,
1891 s->h_edge_pos, v_edge_pos);
1892 srcY = s->edge_emu_buffer;
1893 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1894 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1895 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1896 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1899 /* if we deal with range reduction we need to scale source blocks */
1900 if (v->rangeredfrm) {
1902 uint8_t *src, *src2;
1905 for (j = 0; j < 17 + s->mspel * 2; j++) {
1906 for (i = 0; i < 17 + s->mspel * 2; i++)
1907 src[i] = ((src[i] - 128) >> 1) + 128;
1912 for (j = 0; j < 9; j++) {
1913 for (i = 0; i < 9; i++) {
1914 src[i] = ((src[i] - 128) >> 1) + 128;
1915 src2[i] = ((src2[i] - 128) >> 1) + 128;
1917 src += s->uvlinesize;
1918 src2 += s->uvlinesize;
1921 srcY += s->mspel * (1 + s->linesize);
1924 if (v->field_mode && v->second_field) {
1925 off = s->current_picture_ptr->f.linesize[0];
1926 off_uv = s->current_picture_ptr->f.linesize[1];
1933 dxy = ((my & 3) << 2) | (mx & 3);
1934 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
1935 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1936 srcY += s->linesize * 8;
1937 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
1938 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1940 dxy = (my & 2) | ((mx & 2) >> 1);
1943 dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1945 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1948 if (s->flags & CODEC_FLAG_GRAY) return;
1949 /* Chroma MC always uses qpel blilinear */
1950 uvmx = (uvmx & 3) << 1;
1951 uvmy = (uvmy & 3) << 1;
1953 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1954 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1956 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1957 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1961 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1965 #if B_FRACTION_DEN==256
1969 return 2 * ((value * n + 255) >> 9);
1970 return (value * n + 128) >> 8;
1973 n -= B_FRACTION_DEN;
1975 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1976 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1980 static av_always_inline int scale_mv_intfi(int value, int bfrac, int inv,
1981 int qs, int qs_last)
1989 return (value * n + 255) >> 9;
1991 return (value * n + 128) >> 8;
1994 /** Reconstruct motion vector for B-frame and do motion compensation
1996 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
1997 int direct, int mode)
2000 v->mv_mode2 = v->mv_mode;
2001 v->mv_mode = MV_PMODE_INTENSITY_COMP;
2007 v->mv_mode = v->mv_mode2;
2010 if (mode == BMV_TYPE_INTERPOLATED) {
2014 v->mv_mode = v->mv_mode2;
2018 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2019 v->mv_mode = v->mv_mode2;
2020 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2022 v->mv_mode = v->mv_mode2;
2025 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2026 int direct, int mvtype)
2028 MpegEncContext *s = &v->s;
2029 int xy, wrap, off = 0;
2034 const uint8_t *is_intra = v->mb_type[0];
2038 /* scale MV difference to be quad-pel */
2039 dmv_x[0] <<= 1 - s->quarter_sample;
2040 dmv_y[0] <<= 1 - s->quarter_sample;
2041 dmv_x[1] <<= 1 - s->quarter_sample;
2042 dmv_y[1] <<= 1 - s->quarter_sample;
2044 wrap = s->b8_stride;
2045 xy = s->block_index[0];
2048 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
2049 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
2050 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
2051 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
2054 if (!v->field_mode) {
2055 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2056 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2057 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2058 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2060 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2061 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));
2062 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));
2063 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));
2064 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));
2067 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2068 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2069 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2070 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2074 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2075 C = s->current_picture.f.motion_val[0][xy - 2];
2076 A = s->current_picture.f.motion_val[0][xy - wrap * 2];
2077 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2078 B = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
2080 if (!s->mb_x) C[0] = C[1] = 0;
2081 if (!s->first_slice_line) { // predictor A is not out of bounds
2082 if (s->mb_width == 1) {
2086 px = mid_pred(A[0], B[0], C[0]);
2087 py = mid_pred(A[1], B[1], C[1]);
2089 } else if (s->mb_x) { // predictor C is not out of bounds
2095 /* Pullback MV as specified in 8.3.5.3.4 */
2098 if (v->profile < PROFILE_ADVANCED) {
2099 qx = (s->mb_x << 5);
2100 qy = (s->mb_y << 5);
2101 X = (s->mb_width << 5) - 4;
2102 Y = (s->mb_height << 5) - 4;
2103 if (qx + px < -28) px = -28 - qx;
2104 if (qy + py < -28) py = -28 - qy;
2105 if (qx + px > X) px = X - qx;
2106 if (qy + py > Y) py = Y - qy;
2108 qx = (s->mb_x << 6);
2109 qy = (s->mb_y << 6);
2110 X = (s->mb_width << 6) - 4;
2111 Y = (s->mb_height << 6) - 4;
2112 if (qx + px < -60) px = -60 - qx;
2113 if (qy + py < -60) py = -60 - qy;
2114 if (qx + px > X) px = X - qx;
2115 if (qy + py > Y) py = Y - qy;
2118 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2119 if (0 && !s->first_slice_line && s->mb_x) {
2120 if (is_intra[xy - wrap])
2121 sum = FFABS(px) + FFABS(py);
2123 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2125 if (get_bits1(&s->gb)) {
2133 if (is_intra[xy - 2])
2134 sum = FFABS(px) + FFABS(py);
2136 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2138 if (get_bits1(&s->gb)) {
2148 /* store MV using signed modulus of MV range defined in 4.11 */
2149 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2150 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2152 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2153 C = s->current_picture.f.motion_val[1][xy - 2];
2154 A = s->current_picture.f.motion_val[1][xy - wrap * 2];
2155 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2156 B = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
2160 if (!s->first_slice_line) { // predictor A is not out of bounds
2161 if (s->mb_width == 1) {
2165 px = mid_pred(A[0], B[0], C[0]);
2166 py = mid_pred(A[1], B[1], C[1]);
2168 } else if (s->mb_x) { // predictor C is not out of bounds
2174 /* Pullback MV as specified in 8.3.5.3.4 */
2177 if (v->profile < PROFILE_ADVANCED) {
2178 qx = (s->mb_x << 5);
2179 qy = (s->mb_y << 5);
2180 X = (s->mb_width << 5) - 4;
2181 Y = (s->mb_height << 5) - 4;
2182 if (qx + px < -28) px = -28 - qx;
2183 if (qy + py < -28) py = -28 - qy;
2184 if (qx + px > X) px = X - qx;
2185 if (qy + py > Y) py = Y - qy;
2187 qx = (s->mb_x << 6);
2188 qy = (s->mb_y << 6);
2189 X = (s->mb_width << 6) - 4;
2190 Y = (s->mb_height << 6) - 4;
2191 if (qx + px < -60) px = -60 - qx;
2192 if (qy + py < -60) py = -60 - qy;
2193 if (qx + px > X) px = X - qx;
2194 if (qy + py > Y) py = Y - qy;
2197 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2198 if (0 && !s->first_slice_line && s->mb_x) {
2199 if (is_intra[xy - wrap])
2200 sum = FFABS(px) + FFABS(py);
2202 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2204 if (get_bits1(&s->gb)) {
2212 if (is_intra[xy - 2])
2213 sum = FFABS(px) + FFABS(py);
2215 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2217 if (get_bits1(&s->gb)) {
2227 /* store MV using signed modulus of MV range defined in 4.11 */
2229 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2230 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2232 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
2233 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
2234 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
2235 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
2238 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2240 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2241 MpegEncContext *s = &v->s;
2242 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2244 if (v->bmvtype == BMV_TYPE_DIRECT) {
2245 int total_opp, k, f;
2246 if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2247 s->mv[0][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2248 v->bfraction, 0, s->quarter_sample, v->qs_last);
2249 s->mv[0][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2250 v->bfraction, 0, s->quarter_sample, v->qs_last);
2251 s->mv[1][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2252 v->bfraction, 1, s->quarter_sample, v->qs_last);
2253 s->mv[1][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2254 v->bfraction, 1, s->quarter_sample, v->qs_last);
2256 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2257 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2258 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2259 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2260 f = (total_opp > 2) ? 1 : 0;
2262 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2263 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2266 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2267 for (k = 0; k < 4; k++) {
2268 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2269 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2270 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2271 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2272 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2273 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2277 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2278 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);
2279 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);
2282 if (dir) { // backward
2283 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);
2284 if (n == 3 || mv1) {
2285 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2288 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);
2289 if (n == 3 || mv1) {
2290 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2295 /** Get predicted DC value for I-frames only
2296 * prediction dir: left=0, top=1
2297 * @param s MpegEncContext
2298 * @param overlap flag indicating that overlap filtering is used
2299 * @param pq integer part of picture quantizer
2300 * @param[in] n block index in the current MB
2301 * @param dc_val_ptr Pointer to DC predictor
2302 * @param dir_ptr Prediction direction for use in AC prediction
2304 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2305 int16_t **dc_val_ptr, int *dir_ptr)
2307 int a, b, c, wrap, pred, scale;
2309 static const uint16_t dcpred[32] = {
2310 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2311 114, 102, 93, 85, 79, 73, 68, 64,
2312 60, 57, 54, 51, 49, 47, 45, 43,
2313 41, 39, 38, 37, 35, 34, 33
2316 /* find prediction - wmv3_dc_scale always used here in fact */
2317 if (n < 4) scale = s->y_dc_scale;
2318 else scale = s->c_dc_scale;
2320 wrap = s->block_wrap[n];
2321 dc_val = s->dc_val[0] + s->block_index[n];
2327 b = dc_val[ - 1 - wrap];
2328 a = dc_val[ - wrap];
2330 if (pq < 9 || !overlap) {
2331 /* Set outer values */
2332 if (s->first_slice_line && (n != 2 && n != 3))
2333 b = a = dcpred[scale];
2334 if (s->mb_x == 0 && (n != 1 && n != 3))
2335 b = c = dcpred[scale];
2337 /* Set outer values */
2338 if (s->first_slice_line && (n != 2 && n != 3))
2340 if (s->mb_x == 0 && (n != 1 && n != 3))
2344 if (abs(a - b) <= abs(b - c)) {
2346 *dir_ptr = 1; // left
2349 *dir_ptr = 0; // top
2352 /* update predictor */
2353 *dc_val_ptr = &dc_val[0];
2358 /** Get predicted DC value
2359 * prediction dir: left=0, top=1
2360 * @param s MpegEncContext
2361 * @param overlap flag indicating that overlap filtering is used
2362 * @param pq integer part of picture quantizer
2363 * @param[in] n block index in the current MB
2364 * @param a_avail flag indicating top block availability
2365 * @param c_avail flag indicating left block availability
2366 * @param dc_val_ptr Pointer to DC predictor
2367 * @param dir_ptr Prediction direction for use in AC prediction
2369 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2370 int a_avail, int c_avail,
2371 int16_t **dc_val_ptr, int *dir_ptr)
2373 int a, b, c, wrap, pred;
2375 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2378 wrap = s->block_wrap[n];
2379 dc_val = s->dc_val[0] + s->block_index[n];
2385 b = dc_val[ - 1 - wrap];
2386 a = dc_val[ - wrap];
2387 /* scale predictors if needed */
2388 q1 = s->current_picture.f.qscale_table[mb_pos];
2389 if (c_avail && (n != 1 && n != 3)) {
2390 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2392 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2394 if (a_avail && (n != 2 && n != 3)) {
2395 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2397 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2399 if (a_avail && c_avail && (n != 3)) {
2404 off -= s->mb_stride;
2405 q2 = s->current_picture.f.qscale_table[off];
2407 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2410 if (a_avail && c_avail) {
2411 if (abs(a - b) <= abs(b - c)) {
2413 *dir_ptr = 1; // left
2416 *dir_ptr = 0; // top
2418 } else if (a_avail) {
2420 *dir_ptr = 0; // top
2421 } else if (c_avail) {
2423 *dir_ptr = 1; // left
2426 *dir_ptr = 1; // left
2429 /* update predictor */
2430 *dc_val_ptr = &dc_val[0];
2434 /** @} */ // Block group
2437 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2438 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2442 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2443 uint8_t **coded_block_ptr)
2445 int xy, wrap, pred, a, b, c;
2447 xy = s->block_index[n];
2448 wrap = s->b8_stride;
2453 a = s->coded_block[xy - 1 ];
2454 b = s->coded_block[xy - 1 - wrap];
2455 c = s->coded_block[xy - wrap];
2464 *coded_block_ptr = &s->coded_block[xy];
2470 * Decode one AC coefficient
2471 * @param v The VC1 context
2472 * @param last Last coefficient
2473 * @param skip How much zero coefficients to skip
2474 * @param value Decoded AC coefficient value
2475 * @param codingset set of VLC to decode data
2478 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2479 int *value, int codingset)
2481 GetBitContext *gb = &v->s.gb;
2482 int index, escape, run = 0, level = 0, lst = 0;
2484 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2485 if (index != ff_vc1_ac_sizes[codingset] - 1) {
2486 run = vc1_index_decode_table[codingset][index][0];
2487 level = vc1_index_decode_table[codingset][index][1];
2488 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2492 escape = decode210(gb);
2494 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2495 run = vc1_index_decode_table[codingset][index][0];
2496 level = vc1_index_decode_table[codingset][index][1];
2497 lst = index >= vc1_last_decode_table[codingset];
2500 level += vc1_last_delta_level_table[codingset][run];
2502 level += vc1_delta_level_table[codingset][run];
2505 run += vc1_last_delta_run_table[codingset][level] + 1;
2507 run += vc1_delta_run_table[codingset][level] + 1;
2513 lst = get_bits1(gb);
2514 if (v->s.esc3_level_length == 0) {
2515 if (v->pq < 8 || v->dquantfrm) { // table 59
2516 v->s.esc3_level_length = get_bits(gb, 3);
2517 if (!v->s.esc3_level_length)
2518 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2519 } else { // table 60
2520 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2522 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2524 run = get_bits(gb, v->s.esc3_run_length);
2525 sign = get_bits1(gb);
2526 level = get_bits(gb, v->s.esc3_level_length);
2537 /** Decode intra block in intra frames - should be faster than decode_intra_block
2538 * @param v VC1Context
2539 * @param block block to decode
2540 * @param[in] n subblock index
2541 * @param coded are AC coeffs present or not
2542 * @param codingset set of VLC to decode data
2544 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
2545 int coded, int codingset)
2547 GetBitContext *gb = &v->s.gb;
2548 MpegEncContext *s = &v->s;
2549 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2552 int16_t *ac_val, *ac_val2;
2555 /* Get DC differential */
2557 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2559 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2562 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2566 if (dcdiff == 119 /* ESC index value */) {
2567 /* TODO: Optimize */
2568 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2569 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2570 else dcdiff = get_bits(gb, 8);
2573 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2574 else if (v->pq == 2)
2575 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2582 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2585 /* Store the quantized DC coeff, used for prediction */
2587 block[0] = dcdiff * s->y_dc_scale;
2589 block[0] = dcdiff * s->c_dc_scale;
2600 int last = 0, skip, value;
2601 const uint8_t *zz_table;
2605 scale = v->pq * 2 + v->halfpq;
2609 zz_table = v->zz_8x8[2];
2611 zz_table = v->zz_8x8[3];
2613 zz_table = v->zz_8x8[1];
2615 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2617 if (dc_pred_dir) // left
2620 ac_val -= 16 * s->block_wrap[n];
2623 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2627 block[zz_table[i++]] = value;
2630 /* apply AC prediction if needed */
2632 if (dc_pred_dir) { // left
2633 for (k = 1; k < 8; k++)
2634 block[k << v->left_blk_sh] += ac_val[k];
2636 for (k = 1; k < 8; k++)
2637 block[k << v->top_blk_sh] += ac_val[k + 8];
2640 /* save AC coeffs for further prediction */
2641 for (k = 1; k < 8; k++) {
2642 ac_val2[k] = block[k << v->left_blk_sh];
2643 ac_val2[k + 8] = block[k << v->top_blk_sh];
2646 /* scale AC coeffs */
2647 for (k = 1; k < 64; k++)
2651 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2654 if (s->ac_pred) i = 63;
2660 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2664 scale = v->pq * 2 + v->halfpq;
2665 memset(ac_val2, 0, 16 * 2);
2666 if (dc_pred_dir) { // left
2669 memcpy(ac_val2, ac_val, 8 * 2);
2671 ac_val -= 16 * s->block_wrap[n];
2673 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2676 /* apply AC prediction if needed */
2678 if (dc_pred_dir) { //left
2679 for (k = 1; k < 8; k++) {
2680 block[k << v->left_blk_sh] = ac_val[k] * scale;
2681 if (!v->pquantizer && block[k << v->left_blk_sh])
2682 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2685 for (k = 1; k < 8; k++) {
2686 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2687 if (!v->pquantizer && block[k << v->top_blk_sh])
2688 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2694 s->block_last_index[n] = i;
2699 /** Decode intra block in intra frames - should be faster than decode_intra_block
2700 * @param v VC1Context
2701 * @param block block to decode
2702 * @param[in] n subblock number
2703 * @param coded are AC coeffs present or not
2704 * @param codingset set of VLC to decode data
2705 * @param mquant quantizer value for this macroblock
2707 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
2708 int coded, int codingset, int mquant)
2710 GetBitContext *gb = &v->s.gb;
2711 MpegEncContext *s = &v->s;
2712 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2715 int16_t *ac_val, *ac_val2;
2717 int a_avail = v->a_avail, c_avail = v->c_avail;
2718 int use_pred = s->ac_pred;
2721 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2723 /* Get DC differential */
2725 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2727 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2730 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2734 if (dcdiff == 119 /* ESC index value */) {
2735 /* TODO: Optimize */
2736 if (mquant == 1) dcdiff = get_bits(gb, 10);
2737 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2738 else dcdiff = get_bits(gb, 8);
2741 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2742 else if (mquant == 2)
2743 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2750 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2753 /* Store the quantized DC coeff, used for prediction */
2755 block[0] = dcdiff * s->y_dc_scale;
2757 block[0] = dcdiff * s->c_dc_scale;
2763 /* check if AC is needed at all */
2764 if (!a_avail && !c_avail)
2766 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2769 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2771 if (dc_pred_dir) // left
2774 ac_val -= 16 * s->block_wrap[n];
2776 q1 = s->current_picture.f.qscale_table[mb_pos];
2777 if ( dc_pred_dir && c_avail && mb_pos)
2778 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2779 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2780 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2781 if ( dc_pred_dir && n == 1)
2783 if (!dc_pred_dir && n == 2)
2789 int last = 0, skip, value;
2790 const uint8_t *zz_table;
2794 if (!use_pred && v->fcm == ILACE_FRAME) {
2795 zz_table = v->zzi_8x8;
2797 if (!dc_pred_dir) // top
2798 zz_table = v->zz_8x8[2];
2800 zz_table = v->zz_8x8[3];
2803 if (v->fcm != ILACE_FRAME)
2804 zz_table = v->zz_8x8[1];
2806 zz_table = v->zzi_8x8;
2810 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2814 block[zz_table[i++]] = value;
2817 /* apply AC prediction if needed */
2819 /* scale predictors if needed*/
2820 if (q2 && q1 != q2) {
2821 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2822 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2824 if (dc_pred_dir) { // left
2825 for (k = 1; k < 8; k++)
2826 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2828 for (k = 1; k < 8; k++)
2829 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2832 if (dc_pred_dir) { //left
2833 for (k = 1; k < 8; k++)
2834 block[k << v->left_blk_sh] += ac_val[k];
2836 for (k = 1; k < 8; k++)
2837 block[k << v->top_blk_sh] += ac_val[k + 8];
2841 /* save AC coeffs for further prediction */
2842 for (k = 1; k < 8; k++) {
2843 ac_val2[k ] = block[k << v->left_blk_sh];
2844 ac_val2[k + 8] = block[k << v->top_blk_sh];
2847 /* scale AC coeffs */
2848 for (k = 1; k < 64; k++)
2852 block[k] += (block[k] < 0) ? -mquant : mquant;
2855 if (use_pred) i = 63;
2856 } else { // no AC coeffs
2859 memset(ac_val2, 0, 16 * 2);
2860 if (dc_pred_dir) { // left
2862 memcpy(ac_val2, ac_val, 8 * 2);
2863 if (q2 && q1 != q2) {
2864 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2865 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2866 for (k = 1; k < 8; k++)
2867 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2872 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2873 if (q2 && q1 != q2) {
2874 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2875 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2876 for (k = 1; k < 8; k++)
2877 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2882 /* apply AC prediction if needed */
2884 if (dc_pred_dir) { // left
2885 for (k = 1; k < 8; k++) {
2886 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2887 if (!v->pquantizer && block[k << v->left_blk_sh])
2888 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2891 for (k = 1; k < 8; k++) {
2892 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2893 if (!v->pquantizer && block[k << v->top_blk_sh])
2894 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2900 s->block_last_index[n] = i;
2905 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2906 * @param v VC1Context
2907 * @param block block to decode
2908 * @param[in] n subblock index
2909 * @param coded are AC coeffs present or not
2910 * @param mquant block quantizer
2911 * @param codingset set of VLC to decode data
2913 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
2914 int coded, int mquant, int codingset)
2916 GetBitContext *gb = &v->s.gb;
2917 MpegEncContext *s = &v->s;
2918 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2921 int16_t *ac_val, *ac_val2;
2923 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2924 int a_avail = v->a_avail, c_avail = v->c_avail;
2925 int use_pred = s->ac_pred;
2929 s->dsp.clear_block(block);
2931 /* XXX: Guard against dumb values of mquant */
2932 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2934 /* Set DC scale - y and c use the same */
2935 s->y_dc_scale = s->y_dc_scale_table[mquant];
2936 s->c_dc_scale = s->c_dc_scale_table[mquant];
2938 /* Get DC differential */
2940 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2942 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2945 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2949 if (dcdiff == 119 /* ESC index value */) {
2950 /* TODO: Optimize */
2951 if (mquant == 1) dcdiff = get_bits(gb, 10);
2952 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2953 else dcdiff = get_bits(gb, 8);
2956 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2957 else if (mquant == 2)
2958 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2965 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2968 /* Store the quantized DC coeff, used for prediction */
2971 block[0] = dcdiff * s->y_dc_scale;
2973 block[0] = dcdiff * s->c_dc_scale;
2979 /* check if AC is needed at all and adjust direction if needed */
2980 if (!a_avail) dc_pred_dir = 1;
2981 if (!c_avail) dc_pred_dir = 0;
2982 if (!a_avail && !c_avail) use_pred = 0;
2983 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2986 scale = mquant * 2 + v->halfpq;
2988 if (dc_pred_dir) //left
2991 ac_val -= 16 * s->block_wrap[n];
2993 q1 = s->current_picture.f.qscale_table[mb_pos];
2994 if (dc_pred_dir && c_avail && mb_pos)
2995 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2996 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2997 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2998 if ( dc_pred_dir && n == 1)
3000 if (!dc_pred_dir && n == 2)
3002 if (n == 3) q2 = q1;
3005 int last = 0, skip, value;
3009 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3013 if (v->fcm == PROGRESSIVE)
3014 block[v->zz_8x8[0][i++]] = value;
3016 if (use_pred && (v->fcm == ILACE_FRAME)) {
3017 if (!dc_pred_dir) // top
3018 block[v->zz_8x8[2][i++]] = value;
3020 block[v->zz_8x8[3][i++]] = value;
3022 block[v->zzi_8x8[i++]] = value;
3027 /* apply AC prediction if needed */
3029 /* scale predictors if needed*/
3030 if (q2 && q1 != q2) {
3031 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3032 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3034 if (dc_pred_dir) { // left
3035 for (k = 1; k < 8; k++)
3036 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3038 for (k = 1; k < 8; k++)
3039 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3042 if (dc_pred_dir) { // left
3043 for (k = 1; k < 8; k++)
3044 block[k << v->left_blk_sh] += ac_val[k];
3046 for (k = 1; k < 8; k++)
3047 block[k << v->top_blk_sh] += ac_val[k + 8];
3051 /* save AC coeffs for further prediction */
3052 for (k = 1; k < 8; k++) {
3053 ac_val2[k ] = block[k << v->left_blk_sh];
3054 ac_val2[k + 8] = block[k << v->top_blk_sh];
3057 /* scale AC coeffs */
3058 for (k = 1; k < 64; k++)
3062 block[k] += (block[k] < 0) ? -mquant : mquant;
3065 if (use_pred) i = 63;
3066 } else { // no AC coeffs
3069 memset(ac_val2, 0, 16 * 2);
3070 if (dc_pred_dir) { // left
3072 memcpy(ac_val2, ac_val, 8 * 2);
3073 if (q2 && q1 != q2) {
3074 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3075 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3076 for (k = 1; k < 8; k++)
3077 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3082 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3083 if (q2 && q1 != q2) {
3084 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3085 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3086 for (k = 1; k < 8; k++)
3087 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3092 /* apply AC prediction if needed */
3094 if (dc_pred_dir) { // left
3095 for (k = 1; k < 8; k++) {
3096 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3097 if (!v->pquantizer && block[k << v->left_blk_sh])
3098 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3101 for (k = 1; k < 8; k++) {
3102 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3103 if (!v->pquantizer && block[k << v->top_blk_sh])
3104 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3110 s->block_last_index[n] = i;
3117 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
3118 int mquant, int ttmb, int first_block,
3119 uint8_t *dst, int linesize, int skip_block,
3122 MpegEncContext *s = &v->s;
3123 GetBitContext *gb = &s->gb;
3126 int scale, off, idx, last, skip, value;
3127 int ttblk = ttmb & 7;
3130 s->dsp.clear_block(block);
3133 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)];
3135 if (ttblk == TT_4X4) {
3136 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3138 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3139 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3140 || (!v->res_rtm_flag && !first_block))) {
3141 subblkpat = decode012(gb);
3143 subblkpat ^= 3; // swap decoded pattern bits
3144 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3146 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3149 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3151 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3152 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3153 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3156 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3157 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3166 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3171 idx = v->zz_8x8[0][i++];
3173 idx = v->zzi_8x8[i++];
3174 block[idx] = value * scale;
3176 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3180 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3182 v->vc1dsp.vc1_inv_trans_8x8(block);
3183 s->dsp.add_pixels_clamped(block, dst, linesize);
3188 pat = ~subblkpat & 0xF;
3189 for (j = 0; j < 4; j++) {
3190 last = subblkpat & (1 << (3 - j));
3192 off = (j & 1) * 4 + (j & 2) * 16;
3194 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3199 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3201 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3202 block[idx + off] = value * scale;
3204 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3206 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3208 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3210 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3215 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3216 for (j = 0; j < 2; j++) {
3217 last = subblkpat & (1 << (1 - j));
3221 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3226 idx = v->zz_8x4[i++] + off;
3228 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3229 block[idx] = value * scale;
3231 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3233 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3235 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3237 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3242 pat = ~(subblkpat * 5) & 0xF;
3243 for (j = 0; j < 2; j++) {
3244 last = subblkpat & (1 << (1 - j));
3248 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3253 idx = v->zz_4x8[i++] + off;
3255 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3256 block[idx] = value * scale;
3258 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3260 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3262 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3264 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3270 *ttmb_out |= ttblk << (n * 4);
3274 /** @} */ // Macroblock group
3276 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3277 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3279 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3281 MpegEncContext *s = &v->s;
3282 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3283 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3284 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3285 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3286 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3289 if (block_num > 3) {
3290 dst = s->dest[block_num - 3];
3292 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3294 if (s->mb_y != s->end_mb_y || block_num < 2) {
3298 if (block_num > 3) {
3299 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3300 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3301 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3302 mv_stride = s->mb_stride;
3304 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3305 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3306 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3307 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3308 mv_stride = s->b8_stride;
3309 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3312 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3313 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3314 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3316 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3318 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3321 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3323 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3328 dst -= 4 * linesize;
3329 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3330 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3331 idx = (block_cbp | (block_cbp >> 2)) & 3;
3333 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3336 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3338 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3343 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3345 MpegEncContext *s = &v->s;
3346 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3347 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3348 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3349 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3350 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3353 if (block_num > 3) {
3354 dst = s->dest[block_num - 3] - 8 * linesize;
3356 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3359 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3362 if (block_num > 3) {
3363 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3364 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3365 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3367 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3368 : (mb_cbp >> ((block_num + 1) * 4));
3369 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3370 : (mb_is_intra >> ((block_num + 1) * 4));
3371 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3373 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3374 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3376 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3378 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3381 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3383 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3389 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3390 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3391 idx = (block_cbp | (block_cbp >> 1)) & 5;
3393 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3396 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3398 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3403 static void vc1_apply_p_loop_filter(VC1Context *v)
3405 MpegEncContext *s = &v->s;
3408 for (i = 0; i < 6; i++) {
3409 vc1_apply_p_v_loop_filter(v, i);
3412 /* V always precedes H, therefore we run H one MB before V;
3413 * at the end of a row, we catch up to complete the row */
3415 for (i = 0; i < 6; i++) {
3416 vc1_apply_p_h_loop_filter(v, i);
3418 if (s->mb_x == s->mb_width - 1) {
3420 ff_update_block_index(s);
3421 for (i = 0; i < 6; i++) {
3422 vc1_apply_p_h_loop_filter(v, i);
3428 /** Decode one P-frame MB
3430 static int vc1_decode_p_mb(VC1Context *v)
3432 MpegEncContext *s = &v->s;
3433 GetBitContext *gb = &s->gb;
3435 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3436 int cbp; /* cbp decoding stuff */
3437 int mqdiff, mquant; /* MB quantization */
3438 int ttmb = v->ttfrm; /* MB Transform type */
3440 int mb_has_coeffs = 1; /* last_flag */
3441 int dmv_x, dmv_y; /* Differential MV components */
3442 int index, index1; /* LUT indexes */
3443 int val, sign; /* temp values */
3444 int first_block = 1;
3446 int skipped, fourmv;
3447 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3449 mquant = v->pq; /* lossy initialization */
3451 if (v->mv_type_is_raw)
3452 fourmv = get_bits1(gb);
3454 fourmv = v->mv_type_mb_plane[mb_pos];
3456 skipped = get_bits1(gb);
3458 skipped = v->s.mbskip_table[mb_pos];
3460 if (!fourmv) { /* 1MV mode */
3462 GET_MVDATA(dmv_x, dmv_y);
3465 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3466 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3468 s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3469 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3471 /* FIXME Set DC val for inter block ? */
3472 if (s->mb_intra && !mb_has_coeffs) {
3474 s->ac_pred = get_bits1(gb);
3476 } else if (mb_has_coeffs) {
3478 s->ac_pred = get_bits1(gb);
3479 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3485 s->current_picture.f.qscale_table[mb_pos] = mquant;
3487 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3488 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3489 VC1_TTMB_VLC_BITS, 2);
3490 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3492 for (i = 0; i < 6; i++) {
3493 s->dc_val[0][s->block_index[i]] = 0;
3495 val = ((cbp >> (5 - i)) & 1);
3496 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3497 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3499 /* check if prediction blocks A and C are available */
3500 v->a_avail = v->c_avail = 0;
3501 if (i == 2 || i == 3 || !s->first_slice_line)
3502 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3503 if (i == 1 || i == 3 || s->mb_x)
3504 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3506 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3507 (i & 4) ? v->codingset2 : v->codingset);
3508 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3510 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3512 for (j = 0; j < 64; j++)
3513 s->block[i][j] <<= 1;
3514 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3515 if (v->pq >= 9 && v->overlap) {
3517 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3519 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3521 block_cbp |= 0xF << (i << 2);
3522 block_intra |= 1 << i;
3524 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3525 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3526 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3527 block_cbp |= pat << (i << 2);
3528 if (!v->ttmbf && ttmb < 8)
3535 for (i = 0; i < 6; i++) {
3536 v->mb_type[0][s->block_index[i]] = 0;
3537 s->dc_val[0][s->block_index[i]] = 0;
3539 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3540 s->current_picture.f.qscale_table[mb_pos] = 0;
3541 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3544 } else { // 4MV mode
3545 if (!skipped /* unskipped MB */) {
3546 int intra_count = 0, coded_inter = 0;
3547 int is_intra[6], is_coded[6];
3549 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3550 for (i = 0; i < 6; i++) {
3551 val = ((cbp >> (5 - i)) & 1);
3552 s->dc_val[0][s->block_index[i]] = 0;
3559 GET_MVDATA(dmv_x, dmv_y);
3561 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3563 vc1_mc_4mv_luma(v, i, 0);
3564 intra_count += s->mb_intra;
3565 is_intra[i] = s->mb_intra;
3566 is_coded[i] = mb_has_coeffs;
3569 is_intra[i] = (intra_count >= 3);
3573 vc1_mc_4mv_chroma(v, 0);
3574 v->mb_type[0][s->block_index[i]] = is_intra[i];
3576 coded_inter = !is_intra[i] & is_coded[i];
3578 // if there are no coded blocks then don't do anything more
3580 if (!intra_count && !coded_inter)
3583 s->current_picture.f.qscale_table[mb_pos] = mquant;
3584 /* test if block is intra and has pred */
3587 for (i = 0; i < 6; i++)
3589 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3590 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3596 s->ac_pred = get_bits1(gb);
3600 if (!v->ttmbf && coded_inter)
3601 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3602 for (i = 0; i < 6; i++) {
3604 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3605 s->mb_intra = is_intra[i];
3607 /* check if prediction blocks A and C are available */
3608 v->a_avail = v->c_avail = 0;
3609 if (i == 2 || i == 3 || !s->first_slice_line)
3610 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3611 if (i == 1 || i == 3 || s->mb_x)
3612 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3614 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3615 (i & 4) ? v->codingset2 : v->codingset);
3616 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3618 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3620 for (j = 0; j < 64; j++)
3621 s->block[i][j] <<= 1;
3622 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3623 (i & 4) ? s->uvlinesize : s->linesize);
3624 if (v->pq >= 9 && v->overlap) {
3626 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3628 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3630 block_cbp |= 0xF << (i << 2);
3631 block_intra |= 1 << i;
3632 } else if (is_coded[i]) {
3633 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3634 first_block, s->dest[dst_idx] + off,
3635 (i & 4) ? s->uvlinesize : s->linesize,
3636 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3638 block_cbp |= pat << (i << 2);
3639 if (!v->ttmbf && ttmb < 8)
3644 } else { // skipped MB
3646 s->current_picture.f.qscale_table[mb_pos] = 0;
3647 for (i = 0; i < 6; i++) {
3648 v->mb_type[0][s->block_index[i]] = 0;
3649 s->dc_val[0][s->block_index[i]] = 0;
3651 for (i = 0; i < 4; i++) {
3652 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3653 vc1_mc_4mv_luma(v, i, 0);
3655 vc1_mc_4mv_chroma(v, 0);
3656 s->current_picture.f.qscale_table[mb_pos] = 0;
3660 v->cbp[s->mb_x] = block_cbp;
3661 v->ttblk[s->mb_x] = block_tt;
3662 v->is_intra[s->mb_x] = block_intra;
3667 /* Decode one macroblock in an interlaced frame p picture */
3669 static int vc1_decode_p_mb_intfr(VC1Context *v)
3671 MpegEncContext *s = &v->s;
3672 GetBitContext *gb = &s->gb;
3674 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3675 int cbp = 0; /* cbp decoding stuff */
3676 int mqdiff, mquant; /* MB quantization */
3677 int ttmb = v->ttfrm; /* MB Transform type */
3679 int mb_has_coeffs = 1; /* last_flag */
3680 int dmv_x, dmv_y; /* Differential MV components */
3681 int val; /* temp value */
3682 int first_block = 1;
3684 int skipped, fourmv = 0, twomv = 0;
3685 int block_cbp = 0, pat, block_tt = 0;
3686 int idx_mbmode = 0, mvbp;
3687 int stride_y, fieldtx;
3689 mquant = v->pq; /* Loosy initialization */
3692 skipped = get_bits1(gb);
3694 skipped = v->s.mbskip_table[mb_pos];
3696 if (v->fourmvswitch)
3697 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3699 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3700 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3701 /* store the motion vector type in a flag (useful later) */
3702 case MV_PMODE_INTFR_4MV:
3704 v->blk_mv_type[s->block_index[0]] = 0;
3705 v->blk_mv_type[s->block_index[1]] = 0;
3706 v->blk_mv_type[s->block_index[2]] = 0;
3707 v->blk_mv_type[s->block_index[3]] = 0;
3709 case MV_PMODE_INTFR_4MV_FIELD:
3711 v->blk_mv_type[s->block_index[0]] = 1;
3712 v->blk_mv_type[s->block_index[1]] = 1;
3713 v->blk_mv_type[s->block_index[2]] = 1;
3714 v->blk_mv_type[s->block_index[3]] = 1;
3716 case MV_PMODE_INTFR_2MV_FIELD:
3718 v->blk_mv_type[s->block_index[0]] = 1;
3719 v->blk_mv_type[s->block_index[1]] = 1;
3720 v->blk_mv_type[s->block_index[2]] = 1;
3721 v->blk_mv_type[s->block_index[3]] = 1;
3723 case MV_PMODE_INTFR_1MV:
3724 v->blk_mv_type[s->block_index[0]] = 0;
3725 v->blk_mv_type[s->block_index[1]] = 0;
3726 v->blk_mv_type[s->block_index[2]] = 0;
3727 v->blk_mv_type[s->block_index[3]] = 0;
3730 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3731 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3732 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3733 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
3734 s->mb_intra = v->is_intra[s->mb_x] = 1;
3735 for (i = 0; i < 6; i++)
3736 v->mb_type[0][s->block_index[i]] = 1;
3737 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3738 mb_has_coeffs = get_bits1(gb);
3740 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3741 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3743 s->current_picture.f.qscale_table[mb_pos] = mquant;
3744 /* Set DC scale - y and c use the same (not sure if necessary here) */
3745 s->y_dc_scale = s->y_dc_scale_table[mquant];
3746 s->c_dc_scale = s->c_dc_scale_table[mquant];
3748 for (i = 0; i < 6; i++) {
3749 s->dc_val[0][s->block_index[i]] = 0;
3751 val = ((cbp >> (5 - i)) & 1);
3752 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3753 v->a_avail = v->c_avail = 0;
3754 if (i == 2 || i == 3 || !s->first_slice_line)
3755 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3756 if (i == 1 || i == 3 || s->mb_x)
3757 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3759 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3760 (i & 4) ? v->codingset2 : v->codingset);
3761 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3762 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3764 stride_y = s->linesize << fieldtx;
3765 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3767 stride_y = s->uvlinesize;
3770 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3774 } else { // inter MB
3775 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3777 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3778 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3779 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3781 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3782 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3783 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3786 s->mb_intra = v->is_intra[s->mb_x] = 0;
3787 for (i = 0; i < 6; i++)
3788 v->mb_type[0][s->block_index[i]] = 0;
3789 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3790 /* for all motion vector read MVDATA and motion compensate each block */
3794 for (i = 0; i < 6; i++) {
3797 val = ((mvbp >> (3 - i)) & 1);
3799 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3801 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3802 vc1_mc_4mv_luma(v, i, 0);
3803 } else if (i == 4) {
3804 vc1_mc_4mv_chroma4(v);
3811 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3813 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3814 vc1_mc_4mv_luma(v, 0, 0);
3815 vc1_mc_4mv_luma(v, 1, 0);
3818 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3820 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3821 vc1_mc_4mv_luma(v, 2, 0);
3822 vc1_mc_4mv_luma(v, 3, 0);
3823 vc1_mc_4mv_chroma4(v);
3825 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3828 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3830 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3834 GET_MQUANT(); // p. 227
3835 s->current_picture.f.qscale_table[mb_pos] = mquant;
3836 if (!v->ttmbf && cbp)
3837 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3838 for (i = 0; i < 6; i++) {
3839 s->dc_val[0][s->block_index[i]] = 0;
3841 val = ((cbp >> (5 - i)) & 1);
3843 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3845 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3847 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3848 first_block, s->dest[dst_idx] + off,
3849 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3850 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3851 block_cbp |= pat << (i << 2);
3852 if (!v->ttmbf && ttmb < 8)
3859 s->mb_intra = v->is_intra[s->mb_x] = 0;
3860 for (i = 0; i < 6; i++) {
3861 v->mb_type[0][s->block_index[i]] = 0;
3862 s->dc_val[0][s->block_index[i]] = 0;
3864 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3865 s->current_picture.f.qscale_table[mb_pos] = 0;
3866 v->blk_mv_type[s->block_index[0]] = 0;
3867 v->blk_mv_type[s->block_index[1]] = 0;
3868 v->blk_mv_type[s->block_index[2]] = 0;
3869 v->blk_mv_type[s->block_index[3]] = 0;
3870 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3873 if (s->mb_x == s->mb_width - 1)
3874 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3878 static int vc1_decode_p_mb_intfi(VC1Context *v)
3880 MpegEncContext *s = &v->s;
3881 GetBitContext *gb = &s->gb;
3883 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3884 int cbp = 0; /* cbp decoding stuff */
3885 int mqdiff, mquant; /* MB quantization */
3886 int ttmb = v->ttfrm; /* MB Transform type */
3888 int mb_has_coeffs = 1; /* last_flag */
3889 int dmv_x, dmv_y; /* Differential MV components */
3890 int val; /* temp values */
3891 int first_block = 1;
3894 int block_cbp = 0, pat, block_tt = 0;
3897 mquant = v->pq; /* Loosy initialization */
3899 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3900 if (idx_mbmode <= 1) { // intra MB
3901 s->mb_intra = v->is_intra[s->mb_x] = 1;
3902 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3903 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3904 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3906 s->current_picture.f.qscale_table[mb_pos] = mquant;
3907 /* Set DC scale - y and c use the same (not sure if necessary here) */
3908 s->y_dc_scale = s->y_dc_scale_table[mquant];
3909 s->c_dc_scale = s->c_dc_scale_table[mquant];
3910 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3911 mb_has_coeffs = idx_mbmode & 1;
3913 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3915 for (i = 0; i < 6; i++) {
3916 s->dc_val[0][s->block_index[i]] = 0;
3917 v->mb_type[0][s->block_index[i]] = 1;
3919 val = ((cbp >> (5 - i)) & 1);
3920 v->a_avail = v->c_avail = 0;
3921 if (i == 2 || i == 3 || !s->first_slice_line)
3922 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3923 if (i == 1 || i == 3 || s->mb_x)
3924 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3926 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3927 (i & 4) ? v->codingset2 : v->codingset);
3928 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3930 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3931 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3932 off += v->second_field ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
3933 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
3934 // TODO: loop filter
3937 s->mb_intra = v->is_intra[s->mb_x] = 0;
3938 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3939 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3940 if (idx_mbmode <= 5) { // 1-MV
3942 if (idx_mbmode & 1) {
3943 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3945 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3947 mb_has_coeffs = !(idx_mbmode & 2);
3949 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3950 for (i = 0; i < 6; i++) {
3952 dmv_x = dmv_y = pred_flag = 0;
3953 val = ((v->fourmvbp >> (3 - i)) & 1);
3955 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3957 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3958 vc1_mc_4mv_luma(v, i, 0);
3960 vc1_mc_4mv_chroma(v, 0);
3962 mb_has_coeffs = idx_mbmode & 1;
3965 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3969 s->current_picture.f.qscale_table[mb_pos] = mquant;
3970 if (!v->ttmbf && cbp) {
3971 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3974 for (i = 0; i < 6; i++) {
3975 s->dc_val[0][s->block_index[i]] = 0;
3977 val = ((cbp >> (5 - i)) & 1);
3978 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
3979 if (v->second_field)
3980 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
3982 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3983 first_block, s->dest[dst_idx] + off,
3984 (i & 4) ? s->uvlinesize : s->linesize,
3985 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3987 block_cbp |= pat << (i << 2);
3988 if (!v->ttmbf && ttmb < 8) ttmb = -1;
3993 if (s->mb_x == s->mb_width - 1)
3994 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
3998 /** Decode one B-frame MB (in Main profile)
4000 static void vc1_decode_b_mb(VC1Context *v)
4002 MpegEncContext *s = &v->s;
4003 GetBitContext *gb = &s->gb;
4005 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4006 int cbp = 0; /* cbp decoding stuff */
4007 int mqdiff, mquant; /* MB quantization */
4008 int ttmb = v->ttfrm; /* MB Transform type */
4009 int mb_has_coeffs = 0; /* last_flag */
4010 int index, index1; /* LUT indexes */
4011 int val, sign; /* temp values */
4012 int first_block = 1;
4014 int skipped, direct;
4015 int dmv_x[2], dmv_y[2];
4016 int bmvtype = BMV_TYPE_BACKWARD;
4018 mquant = v->pq; /* lossy initialization */
4022 direct = get_bits1(gb);
4024 direct = v->direct_mb_plane[mb_pos];
4026 skipped = get_bits1(gb);
4028 skipped = v->s.mbskip_table[mb_pos];
4030 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4031 for (i = 0; i < 6; i++) {
4032 v->mb_type[0][s->block_index[i]] = 0;
4033 s->dc_val[0][s->block_index[i]] = 0;
4035 s->current_picture.f.qscale_table[mb_pos] = 0;
4039 GET_MVDATA(dmv_x[0], dmv_y[0]);
4040 dmv_x[1] = dmv_x[0];
4041 dmv_y[1] = dmv_y[0];
4043 if (skipped || !s->mb_intra) {
4044 bmvtype = decode012(gb);
4047 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4050 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4053 bmvtype = BMV_TYPE_INTERPOLATED;
4054 dmv_x[0] = dmv_y[0] = 0;
4058 for (i = 0; i < 6; i++)
4059 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4063 bmvtype = BMV_TYPE_INTERPOLATED;
4064 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4065 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4069 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4072 s->current_picture.f.qscale_table[mb_pos] = mquant;
4074 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4075 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4076 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4077 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4079 if (!mb_has_coeffs && !s->mb_intra) {
4080 /* no coded blocks - effectively skipped */
4081 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4082 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4085 if (s->mb_intra && !mb_has_coeffs) {
4087 s->current_picture.f.qscale_table[mb_pos] = mquant;
4088 s->ac_pred = get_bits1(gb);
4090 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4092 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4093 GET_MVDATA(dmv_x[0], dmv_y[0]);
4094 if (!mb_has_coeffs) {
4095 /* interpolated skipped block */
4096 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4097 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4101 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4103 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4106 s->ac_pred = get_bits1(gb);
4107 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4109 s->current_picture.f.qscale_table[mb_pos] = mquant;
4110 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4111 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4115 for (i = 0; i < 6; i++) {
4116 s->dc_val[0][s->block_index[i]] = 0;
4118 val = ((cbp >> (5 - i)) & 1);
4119 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4120 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4122 /* check if prediction blocks A and C are available */
4123 v->a_avail = v->c_avail = 0;
4124 if (i == 2 || i == 3 || !s->first_slice_line)
4125 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4126 if (i == 1 || i == 3 || s->mb_x)
4127 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4129 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4130 (i & 4) ? v->codingset2 : v->codingset);
4131 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4133 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4135 for (j = 0; j < 64; j++)
4136 s->block[i][j] <<= 1;
4137 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4139 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4140 first_block, s->dest[dst_idx] + off,
4141 (i & 4) ? s->uvlinesize : s->linesize,
4142 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4143 if (!v->ttmbf && ttmb < 8)
4150 /** Decode one B-frame MB (in interlaced field B picture)
4152 static void vc1_decode_b_mb_intfi(VC1Context *v)
4154 MpegEncContext *s = &v->s;
4155 GetBitContext *gb = &s->gb;
4157 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4158 int cbp = 0; /* cbp decoding stuff */
4159 int mqdiff, mquant; /* MB quantization */
4160 int ttmb = v->ttfrm; /* MB Transform type */
4161 int mb_has_coeffs = 0; /* last_flag */
4162 int val; /* temp value */
4163 int first_block = 1;
4166 int dmv_x[2], dmv_y[2], pred_flag[2];
4167 int bmvtype = BMV_TYPE_BACKWARD;
4168 int idx_mbmode, interpmvp;
4170 mquant = v->pq; /* Loosy initialization */
4173 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4174 if (idx_mbmode <= 1) { // intra MB
4175 s->mb_intra = v->is_intra[s->mb_x] = 1;
4176 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4177 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4178 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4180 s->current_picture.f.qscale_table[mb_pos] = mquant;
4181 /* Set DC scale - y and c use the same (not sure if necessary here) */
4182 s->y_dc_scale = s->y_dc_scale_table[mquant];
4183 s->c_dc_scale = s->c_dc_scale_table[mquant];
4184 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4185 mb_has_coeffs = idx_mbmode & 1;
4187 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4189 for (i = 0; i < 6; i++) {
4190 s->dc_val[0][s->block_index[i]] = 0;
4192 val = ((cbp >> (5 - i)) & 1);
4193 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4194 v->a_avail = v->c_avail = 0;
4195 if (i == 2 || i == 3 || !s->first_slice_line)
4196 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4197 if (i == 1 || i == 3 || s->mb_x)
4198 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4200 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4201 (i & 4) ? v->codingset2 : v->codingset);
4202 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4204 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4206 for (j = 0; j < 64; j++)
4207 s->block[i][j] <<= 1;
4208 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4209 off += v->second_field ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4210 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4211 // TODO: yet to perform loop filter
4214 s->mb_intra = v->is_intra[s->mb_x] = 0;
4215 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4216 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4218 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4220 fwd = v->forward_mb_plane[mb_pos];
4221 if (idx_mbmode <= 5) { // 1-MV
4222 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4223 pred_flag[0] = pred_flag[1] = 0;
4225 bmvtype = BMV_TYPE_FORWARD;
4227 bmvtype = decode012(gb);
4230 bmvtype = BMV_TYPE_BACKWARD;
4233 bmvtype = BMV_TYPE_DIRECT;
4236 bmvtype = BMV_TYPE_INTERPOLATED;
4237 interpmvp = get_bits1(gb);
4240 v->bmvtype = bmvtype;
4241 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4242 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4244 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4245 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4247 if (bmvtype == BMV_TYPE_DIRECT) {
4248 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4249 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4251 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4252 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4253 mb_has_coeffs = !(idx_mbmode & 2);
4256 bmvtype = BMV_TYPE_FORWARD;
4257 v->bmvtype = bmvtype;
4258 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4259 for (i = 0; i < 6; i++) {
4261 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4262 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4263 val = ((v->fourmvbp >> (3 - i)) & 1);
4265 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4266 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4267 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4269 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4270 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4272 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4274 mb_has_coeffs = idx_mbmode & 1;
4277 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4281 s->current_picture.f.qscale_table[mb_pos] = mquant;
4282 if (!v->ttmbf && cbp) {
4283 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4286 for (i = 0; i < 6; i++) {
4287 s->dc_val[0][s->block_index[i]] = 0;
4289 val = ((cbp >> (5 - i)) & 1);
4290 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4291 if (v->second_field)
4292 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4294 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4295 first_block, s->dest[dst_idx] + off,
4296 (i & 4) ? s->uvlinesize : s->linesize,
4297 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4298 if (!v->ttmbf && ttmb < 8)
4306 /** Decode blocks of I-frame
4308 static void vc1_decode_i_blocks(VC1Context *v)
4311 MpegEncContext *s = &v->s;
4316 /* select codingmode used for VLC tables selection */
4317 switch (v->y_ac_table_index) {
4319 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4322 v->codingset = CS_HIGH_MOT_INTRA;
4325 v->codingset = CS_MID_RATE_INTRA;
4329 switch (v->c_ac_table_index) {
4331 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4334 v->codingset2 = CS_HIGH_MOT_INTER;
4337 v->codingset2 = CS_MID_RATE_INTER;
4341 /* Set DC scale - y and c use the same */
4342 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4343 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4346 s->mb_x = s->mb_y = 0;
4348 s->first_slice_line = 1;
4349 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4351 ff_init_block_index(s);
4352 for (; s->mb_x < s->mb_width; s->mb_x++) {
4354 ff_update_block_index(s);
4355 dst[0] = s->dest[0];
4356 dst[1] = dst[0] + 8;
4357 dst[2] = s->dest[0] + s->linesize * 8;
4358 dst[3] = dst[2] + 8;
4359 dst[4] = s->dest[1];
4360 dst[5] = s->dest[2];
4361 s->dsp.clear_blocks(s->block[0]);
4362 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4363 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
4364 s->current_picture.f.qscale_table[mb_pos] = v->pq;
4365 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4366 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4368 // do actual MB decoding and displaying
4369 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4370 v->s.ac_pred = get_bits1(&v->s.gb);
4372 for (k = 0; k < 6; k++) {
4373 val = ((cbp >> (5 - k)) & 1);
4376 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4380 cbp |= val << (5 - k);
4382 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4384 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4386 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4387 if (v->pq >= 9 && v->overlap) {
4389 for (j = 0; j < 64; j++)
4390 s->block[k][j] <<= 1;
4391 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4394 for (j = 0; j < 64; j++)
4395 s->block[k][j] = (s->block[k][j] - 64) << 1;
4396 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4400 if (v->pq >= 9 && v->overlap) {
4402 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4403 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4404 if (!(s->flags & CODEC_FLAG_GRAY)) {
4405 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4406 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4409 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4410 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4411 if (!s->first_slice_line) {
4412 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4413 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4414 if (!(s->flags & CODEC_FLAG_GRAY)) {
4415 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4416 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4419 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4420 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4422 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4424 if (get_bits_count(&s->gb) > v->bits) {
4425 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4426 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4427 get_bits_count(&s->gb), v->bits);
4431 if (!v->s.loop_filter)
4432 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4434 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4436 s->first_slice_line = 0;
4438 if (v->s.loop_filter)
4439 ff_draw_horiz_band(s, (s->mb_height - 1) * 16, 16);
4440 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4443 /** Decode blocks of I-frame for advanced profile
4445 static void vc1_decode_i_blocks_adv(VC1Context *v)
4448 MpegEncContext *s = &v->s;
4454 GetBitContext *gb = &s->gb;
4456 /* select codingmode used for VLC tables selection */
4457 switch (v->y_ac_table_index) {
4459 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4462 v->codingset = CS_HIGH_MOT_INTRA;
4465 v->codingset = CS_MID_RATE_INTRA;
4469 switch (v->c_ac_table_index) {
4471 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4474 v->codingset2 = CS_HIGH_MOT_INTER;
4477 v->codingset2 = CS_MID_RATE_INTER;
4482 s->mb_x = s->mb_y = 0;
4484 s->first_slice_line = 1;
4485 s->mb_y = s->start_mb_y;
4486 if (s->start_mb_y) {
4488 ff_init_block_index(s);
4489 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4490 (1 + s->b8_stride) * sizeof(*s->coded_block));
4492 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4494 ff_init_block_index(s);
4495 for (;s->mb_x < s->mb_width; s->mb_x++) {
4496 DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
4497 ff_update_block_index(s);
4498 s->dsp.clear_blocks(block[0]);
4499 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4500 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4501 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4502 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4504 // do actual MB decoding and displaying
4505 if (v->fieldtx_is_raw)
4506 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4507 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4508 if ( v->acpred_is_raw)
4509 v->s.ac_pred = get_bits1(&v->s.gb);
4511 v->s.ac_pred = v->acpred_plane[mb_pos];
4513 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4514 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4518 s->current_picture.f.qscale_table[mb_pos] = mquant;
4519 /* Set DC scale - y and c use the same */
4520 s->y_dc_scale = s->y_dc_scale_table[mquant];
4521 s->c_dc_scale = s->c_dc_scale_table[mquant];
4523 for (k = 0; k < 6; k++) {
4524 val = ((cbp >> (5 - k)) & 1);
4527 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4531 cbp |= val << (5 - k);
4533 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4534 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4536 vc1_decode_i_block_adv(v, block[k], k, val,
4537 (k < 4) ? v->codingset : v->codingset2, mquant);
4539 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4541 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4544 vc1_smooth_overlap_filter_iblk(v);
4545 vc1_put_signed_blocks_clamped(v);
4546 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4548 if (get_bits_count(&s->gb) > v->bits) {
4549 // TODO: may need modification to handle slice coding
4550 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4551 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4552 get_bits_count(&s->gb), v->bits);
4556 if (!v->s.loop_filter)
4557 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4559 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4560 s->first_slice_line = 0;
4563 /* raw bottom MB row */
4565 ff_init_block_index(s);
4566 for (;s->mb_x < s->mb_width; s->mb_x++) {
4567 ff_update_block_index(s);
4568 vc1_put_signed_blocks_clamped(v);
4569 if (v->s.loop_filter)
4570 vc1_loop_filter_iblk_delayed(v, v->pq);
4572 if (v->s.loop_filter)
4573 ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4574 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4575 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4578 static void vc1_decode_p_blocks(VC1Context *v)
4580 MpegEncContext *s = &v->s;
4581 int apply_loop_filter;
4583 /* select codingmode used for VLC tables selection */
4584 switch (v->c_ac_table_index) {
4586 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4589 v->codingset = CS_HIGH_MOT_INTRA;
4592 v->codingset = CS_MID_RATE_INTRA;
4596 switch (v->c_ac_table_index) {
4598 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4601 v->codingset2 = CS_HIGH_MOT_INTER;
4604 v->codingset2 = CS_MID_RATE_INTER;
4608 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
4609 s->first_slice_line = 1;
4610 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
4611 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4613 ff_init_block_index(s);
4614 for (; s->mb_x < s->mb_width; s->mb_x++) {
4615 ff_update_block_index(s);
4617 if (v->fcm == ILACE_FIELD)
4618 vc1_decode_p_mb_intfi(v);
4619 else if (v->fcm == ILACE_FRAME)
4620 vc1_decode_p_mb_intfr(v);
4621 else vc1_decode_p_mb(v);
4622 if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == PROGRESSIVE)
4623 vc1_apply_p_loop_filter(v);
4624 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4625 // TODO: may need modification to handle slice coding
4626 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4627 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4628 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4632 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
4633 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
4634 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4635 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
4636 if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4637 s->first_slice_line = 0;
4639 if (apply_loop_filter) {
4641 ff_init_block_index(s);
4642 for (; s->mb_x < s->mb_width; s->mb_x++) {
4643 ff_update_block_index(s);
4644 vc1_apply_p_loop_filter(v);
4647 if (s->end_mb_y >= s->start_mb_y)
4648 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4649 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4650 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4653 static void vc1_decode_b_blocks(VC1Context *v)
4655 MpegEncContext *s = &v->s;
4657 /* select codingmode used for VLC tables selection */
4658 switch (v->c_ac_table_index) {
4660 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4663 v->codingset = CS_HIGH_MOT_INTRA;
4666 v->codingset = CS_MID_RATE_INTRA;
4670 switch (v->c_ac_table_index) {
4672 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4675 v->codingset2 = CS_HIGH_MOT_INTER;
4678 v->codingset2 = CS_MID_RATE_INTER;
4682 s->first_slice_line = 1;
4683 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4685 ff_init_block_index(s);
4686 for (; s->mb_x < s->mb_width; s->mb_x++) {
4687 ff_update_block_index(s);
4689 if (v->fcm == ILACE_FIELD)
4690 vc1_decode_b_mb_intfi(v);
4693 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4694 // TODO: may need modification to handle slice coding
4695 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4696 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4697 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4700 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4702 if (!v->s.loop_filter)
4703 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4705 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4706 s->first_slice_line = 0;
4708 if (v->s.loop_filter)
4709 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4710 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4711 (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4714 static void vc1_decode_skip_blocks(VC1Context *v)
4716 MpegEncContext *s = &v->s;
4718 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
4719 s->first_slice_line = 1;
4720 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4722 ff_init_block_index(s);
4723 ff_update_block_index(s);
4724 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4725 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4726 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4727 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4728 s->first_slice_line = 0;
4730 s->pict_type = AV_PICTURE_TYPE_P;
4733 static void vc1_decode_blocks(VC1Context *v)
4736 v->s.esc3_level_length = 0;
4738 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
4741 v->left_blk_idx = -1;
4742 v->topleft_blk_idx = 1;
4744 switch (v->s.pict_type) {
4745 case AV_PICTURE_TYPE_I:
4746 if (v->profile == PROFILE_ADVANCED)
4747 vc1_decode_i_blocks_adv(v);
4749 vc1_decode_i_blocks(v);
4751 case AV_PICTURE_TYPE_P:
4752 if (v->p_frame_skipped)
4753 vc1_decode_skip_blocks(v);
4755 vc1_decode_p_blocks(v);
4757 case AV_PICTURE_TYPE_B:
4759 if (v->profile == PROFILE_ADVANCED)
4760 vc1_decode_i_blocks_adv(v);
4762 vc1_decode_i_blocks(v);
4764 vc1_decode_b_blocks(v);
4770 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
4774 * Transform coefficients for both sprites in 16.16 fixed point format,
4775 * in the order they appear in the bitstream:
4777 * rotation 1 (unused)
4779 * rotation 2 (unused)
4786 int effect_type, effect_flag;
4787 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
4788 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
4791 static inline int get_fp_val(GetBitContext* gb)
4793 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
4796 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
4800 switch (get_bits(gb, 2)) {
4803 c[2] = get_fp_val(gb);
4807 c[0] = c[4] = get_fp_val(gb);
4808 c[2] = get_fp_val(gb);
4811 c[0] = get_fp_val(gb);
4812 c[2] = get_fp_val(gb);
4813 c[4] = get_fp_val(gb);
4816 c[0] = get_fp_val(gb);
4817 c[1] = get_fp_val(gb);
4818 c[2] = get_fp_val(gb);
4819 c[3] = get_fp_val(gb);
4820 c[4] = get_fp_val(gb);
4823 c[5] = get_fp_val(gb);
4825 c[6] = get_fp_val(gb);
4830 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
4832 AVCodecContext *avctx = v->s.avctx;
4835 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4836 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
4837 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
4838 av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
4839 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
4840 for (i = 0; i < 7; i++)
4841 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
4842 sd->coefs[sprite][i] / (1<<16),
4843 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
4844 av_log(avctx, AV_LOG_DEBUG, "\n");
4848 if (sd->effect_type = get_bits_long(gb, 30)) {
4849 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
4851 vc1_sprite_parse_transform(gb, sd->effect_params1);
4854 vc1_sprite_parse_transform(gb, sd->effect_params1);
4855 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
4858 for (i = 0; i < sd->effect_pcount1; i++)
4859 sd->effect_params1[i] = get_fp_val(gb);
4861 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
4862 // effect 13 is simple alpha blending and matches the opacity above
4863 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
4864 for (i = 0; i < sd->effect_pcount1; i++)
4865 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4866 sd->effect_params1[i] / (1 << 16),
4867 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
4868 av_log(avctx, AV_LOG_DEBUG, "\n");
4871 sd->effect_pcount2 = get_bits(gb, 16);
4872 if (sd->effect_pcount2 > 10) {
4873 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
4875 } else if (sd->effect_pcount2) {
4877 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
4878 while (++i < sd->effect_pcount2) {
4879 sd->effect_params2[i] = get_fp_val(gb);
4880 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4881 sd->effect_params2[i] / (1 << 16),
4882 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
4884 av_log(avctx, AV_LOG_DEBUG, "\n");
4887 if (sd->effect_flag = get_bits1(gb))
4888 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4890 if (get_bits_count(gb) >= gb->size_in_bits +
4891 (avctx->codec_id == CODEC_ID_WMV3IMAGE ? 64 : 0))
4892 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4893 if (get_bits_count(gb) < gb->size_in_bits - 8)
4894 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4897 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
4899 int i, plane, row, sprite;
4900 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
4901 uint8_t* src_h[2][2];
4902 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
4904 MpegEncContext *s = &v->s;
4906 for (i = 0; i < 2; i++) {
4907 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
4908 xadv[i] = sd->coefs[i][0];
4909 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
4910 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
4912 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
4913 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
4915 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
4917 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
4918 int width = v->output_width>>!!plane;
4920 for (row = 0; row < v->output_height>>!!plane; row++) {
4921 uint8_t *dst = v->sprite_output_frame.data[plane] +
4922 v->sprite_output_frame.linesize[plane] * row;
4924 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4925 uint8_t *iplane = s->current_picture.f.data[plane];
4926 int iline = s->current_picture.f.linesize[plane];
4927 int ycoord = yoff[sprite] + yadv[sprite] * row;
4928 int yline = ycoord >> 16;
4929 ysub[sprite] = ycoord & 0xFFFF;
4931 iplane = s->last_picture.f.data[plane];
4932 iline = s->last_picture.f.linesize[plane];
4934 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4935 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
4937 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + FFMIN(yline + 1, (v->sprite_height>>!!plane)-1) * iline;
4939 if (sr_cache[sprite][0] != yline) {
4940 if (sr_cache[sprite][1] == yline) {
4941 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
4942 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
4944 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
4945 sr_cache[sprite][0] = yline;
4948 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4949 v->vc1dsp.sprite_h(v->sr_rows[sprite][1], iplane + FFMIN(yline + 1, (v->sprite_height>>!!plane)-1) * iline, xoff[sprite], xadv[sprite], width);
4950 sr_cache[sprite][1] = yline + 1;
4952 src_h[sprite][0] = v->sr_rows[sprite][0];
4953 src_h[sprite][1] = v->sr_rows[sprite][1];
4957 if (!v->two_sprites) {
4959 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
4961 memcpy(dst, src_h[0][0], width);
4964 if (ysub[0] && ysub[1]) {
4965 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
4966 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
4967 } else if (ysub[0]) {
4968 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
4969 src_h[1][0], alpha, width);
4970 } else if (ysub[1]) {
4971 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
4972 src_h[0][0], (1<<16)-1-alpha, width);
4974 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
4980 for (i = 0; i < 2; i++) {
4990 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
4992 MpegEncContext *s = &v->s;
4993 AVCodecContext *avctx = s->avctx;
4996 vc1_parse_sprites(v, gb, &sd);
4998 if (!s->current_picture.f.data[0]) {
4999 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5003 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5004 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5008 if (v->sprite_output_frame.data[0])
5009 avctx->release_buffer(avctx, &v->sprite_output_frame);
5011 v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5012 v->sprite_output_frame.reference = 0;
5013 if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
5014 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5018 vc1_draw_sprites(v, &sd);
5023 static void vc1_sprite_flush(AVCodecContext *avctx)
5025 VC1Context *v = avctx->priv_data;
5026 MpegEncContext *s = &v->s;
5027 AVFrame *f = &s->current_picture.f;
5030 /* Windows Media Image codecs have a convergence interval of two keyframes.
5031 Since we can't enforce it, clear to black the missing sprite. This is
5032 wrong but it looks better than doing nothing. */
5035 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5036 for (i = 0; i < v->sprite_height>>!!plane; i++)
5037 memset(f->data[plane] + i * f->linesize[plane],
5038 plane ? 128 : 0, f->linesize[plane]);
5043 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
5045 MpegEncContext *s = &v->s;
5048 /* Allocate mb bitplanes */
5049 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5050 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5051 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5052 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5053 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5054 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5056 v->n_allocated_blks = s->mb_width + 2;
5057 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5058 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5059 v->cbp = v->cbp_base + s->mb_stride;
5060 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5061 v->ttblk = v->ttblk_base + s->mb_stride;
5062 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5063 v->is_intra = v->is_intra_base + s->mb_stride;
5064 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5065 v->luma_mv = v->luma_mv_base + s->mb_stride;
5067 /* allocate block type info in that way so it could be used with s->block_index[] */
5068 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5069 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5070 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5071 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5073 /* allocate memory to store block level MV info */
5074 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5075 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5076 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5077 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5078 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5079 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5080 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
5081 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);
5082 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5083 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5084 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);
5086 /* Init coded blocks info */
5087 if (v->profile == PROFILE_ADVANCED) {
5088 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5090 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5094 ff_intrax8_common_init(&v->x8,s);
5096 if (s->avctx->codec_id == CODEC_ID_WMV3IMAGE || s->avctx->codec_id == CODEC_ID_VC1IMAGE) {
5097 for (i = 0; i < 4; i++)
5098 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5101 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5102 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5109 /** Initialize a VC1/WMV3 decoder
5110 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5111 * @todo TODO: Decypher remaining bits in extra_data
5113 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5115 VC1Context *v = avctx->priv_data;
5116 MpegEncContext *s = &v->s;
5120 /* save the container output size for WMImage */
5121 v->output_width = avctx->width;
5122 v->output_height = avctx->height;
5124 if (!avctx->extradata_size || !avctx->extradata)
5126 if (!(avctx->flags & CODEC_FLAG_GRAY))
5127 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5129 avctx->pix_fmt = PIX_FMT_GRAY8;
5130 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5132 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5133 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5135 if (avctx->idct_algo == FF_IDCT_AUTO) {
5136 avctx->idct_algo = FF_IDCT_WMV2;
5139 if (ff_vc1_init_common(v) < 0)
5141 ff_vc1dsp_init(&v->vc1dsp);
5143 if (avctx->codec_id == CODEC_ID_WMV3 || avctx->codec_id == CODEC_ID_WMV3IMAGE) {
5146 // looks like WMV3 has a sequence header stored in the extradata
5147 // advanced sequence header may be before the first frame
5148 // the last byte of the extradata is a version number, 1 for the
5149 // samples we can decode
5151 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5153 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5156 count = avctx->extradata_size*8 - get_bits_count(&gb);
5158 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5159 count, get_bits(&gb, count));
5160 } else if (count < 0) {
5161 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5163 } else { // VC1/WVC1/WVP2
5164 const uint8_t *start = avctx->extradata;
5165 uint8_t *end = avctx->extradata + avctx->extradata_size;
5166 const uint8_t *next;
5167 int size, buf2_size;
5168 uint8_t *buf2 = NULL;
5169 int seq_initialized = 0, ep_initialized = 0;
5171 if (avctx->extradata_size < 16) {
5172 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5176 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5177 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5179 for (; next < end; start = next) {
5180 next = find_next_marker(start + 4, end);
5181 size = next - start - 4;
5184 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5185 init_get_bits(&gb, buf2, buf2_size * 8);
5186 switch (AV_RB32(start)) {
5187 case VC1_CODE_SEQHDR:
5188 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5192 seq_initialized = 1;
5194 case VC1_CODE_ENTRYPOINT:
5195 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5204 if (!seq_initialized || !ep_initialized) {
5205 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5208 v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
5211 avctx->profile = v->profile;
5212 if (v->profile == PROFILE_ADVANCED)
5213 avctx->level = v->level;
5215 avctx->has_b_frames = !!avctx->max_b_frames;
5217 s->mb_width = (avctx->coded_width + 15) >> 4;
5218 s->mb_height = (avctx->coded_height + 15) >> 4;
5220 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5221 for (i = 0; i < 64; i++) {
5222 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5223 v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5224 v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5225 v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5226 v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5227 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5232 memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5237 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5238 v->sprite_width = avctx->coded_width;
5239 v->sprite_height = avctx->coded_height;
5241 avctx->coded_width = avctx->width = v->output_width;
5242 avctx->coded_height = avctx->height = v->output_height;
5244 // prevent 16.16 overflows
5245 if (v->sprite_width > 1 << 14 ||
5246 v->sprite_height > 1 << 14 ||
5247 v->output_width > 1 << 14 ||
5248 v->output_height > 1 << 14) return -1;
5253 /** Close a VC1/WMV3 decoder
5254 * @warning Initial try at using MpegEncContext stuff
5256 static av_cold int vc1_decode_end(AVCodecContext *avctx)
5258 VC1Context *v = avctx->priv_data;
5261 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
5262 && v->sprite_output_frame.data[0])
5263 avctx->release_buffer(avctx, &v->sprite_output_frame);
5264 for (i = 0; i < 4; i++)
5265 av_freep(&v->sr_rows[i >> 1][i & 1]);
5266 av_freep(&v->hrd_rate);
5267 av_freep(&v->hrd_buffer);
5268 ff_MPV_common_end(&v->s);
5269 av_freep(&v->mv_type_mb_plane);
5270 av_freep(&v->direct_mb_plane);
5271 av_freep(&v->forward_mb_plane);
5272 av_freep(&v->fieldtx_plane);
5273 av_freep(&v->acpred_plane);
5274 av_freep(&v->over_flags_plane);
5275 av_freep(&v->mb_type_base);
5276 av_freep(&v->blk_mv_type_base);
5277 av_freep(&v->mv_f_base);
5278 av_freep(&v->mv_f_last_base);
5279 av_freep(&v->mv_f_next_base);
5280 av_freep(&v->block);
5281 av_freep(&v->cbp_base);
5282 av_freep(&v->ttblk_base);
5283 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5284 av_freep(&v->luma_mv_base);
5285 ff_intrax8_common_end(&v->x8);
5290 /** Decode a VC1/WMV3 frame
5291 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5293 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5294 int *data_size, AVPacket *avpkt)
5296 const uint8_t *buf = avpkt->data;
5297 int buf_size = avpkt->size, n_slices = 0, i;
5298 VC1Context *v = avctx->priv_data;
5299 MpegEncContext *s = &v->s;
5300 AVFrame *pict = data;
5301 uint8_t *buf2 = NULL;
5302 const uint8_t *buf_start = buf;
5303 int mb_height, n_slices1=-1;
5308 } *slices = NULL, *tmp;
5310 if(s->flags & CODEC_FLAG_LOW_DELAY)
5313 /* no supplementary picture */
5314 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5315 /* special case for last picture */
5316 if (s->low_delay == 0 && s->next_picture_ptr) {
5317 *pict = s->next_picture_ptr->f;
5318 s->next_picture_ptr = NULL;
5320 *data_size = sizeof(AVFrame);
5326 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5327 if (v->profile < PROFILE_ADVANCED)
5328 avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
5330 avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
5333 //for advanced profile we may need to parse and unescape data
5334 if (avctx->codec_id == CODEC_ID_VC1 || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5336 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5338 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5339 const uint8_t *start, *end, *next;
5343 for (start = buf, end = buf + buf_size; next < end; start = next) {
5344 next = find_next_marker(start + 4, end);
5345 size = next - start - 4;
5346 if (size <= 0) continue;
5347 switch (AV_RB32(start)) {
5348 case VC1_CODE_FRAME:
5349 if (avctx->hwaccel ||
5350 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5352 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5354 case VC1_CODE_FIELD: {
5356 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5359 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5360 if (!slices[n_slices].buf)
5362 buf_size3 = vc1_unescape_buffer(start + 4, size,
5363 slices[n_slices].buf);
5364 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5366 /* assuming that the field marker is at the exact middle,
5367 hope it's correct */
5368 slices[n_slices].mby_start = s->mb_height >> 1;
5369 n_slices1 = n_slices - 1; // index of the last slice of the first field
5373 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5374 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5375 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5376 ff_vc1_decode_entry_point(avctx, v, &s->gb);
5378 case VC1_CODE_SLICE: {
5380 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5383 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5384 if (!slices[n_slices].buf)
5386 buf_size3 = vc1_unescape_buffer(start + 4, size,
5387 slices[n_slices].buf);
5388 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5390 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5396 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5397 const uint8_t *divider;
5400 divider = find_next_marker(buf, buf + buf_size);
5401 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5402 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5404 } else { // found field marker, unescape second field
5405 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5409 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5410 if (!slices[n_slices].buf)
5412 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5413 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5415 slices[n_slices].mby_start = s->mb_height >> 1;
5416 n_slices1 = n_slices - 1;
5419 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5421 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5423 init_get_bits(&s->gb, buf2, buf_size2*8);
5425 init_get_bits(&s->gb, buf, buf_size*8);
5427 if (v->res_sprite) {
5428 v->new_sprite = !get_bits1(&s->gb);
5429 v->two_sprites = get_bits1(&s->gb);
5430 /* res_sprite means a Windows Media Image stream, CODEC_ID_*IMAGE means
5431 we're using the sprite compositor. These are intentionally kept separate
5432 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5433 the vc1 one for WVP2 */
5434 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5435 if (v->new_sprite) {
5436 // switch AVCodecContext parameters to those of the sprites
5437 avctx->width = avctx->coded_width = v->sprite_width;
5438 avctx->height = avctx->coded_height = v->sprite_height;
5445 if (s->context_initialized &&
5446 (s->width != avctx->coded_width ||
5447 s->height != avctx->coded_height)) {
5448 vc1_decode_end(avctx);
5451 if (!s->context_initialized) {
5452 if (ff_msmpeg4_decode_init(avctx) < 0 || vc1_decode_init_alloc_tables(v) < 0)
5455 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5457 if (v->profile == PROFILE_ADVANCED) {
5458 s->h_edge_pos = avctx->coded_width;
5459 s->v_edge_pos = avctx->coded_height;
5463 /* We need to set current_picture_ptr before reading the header,
5464 * otherwise we cannot store anything in there. */
5465 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5466 int i = ff_find_unused_picture(s, 0);
5469 s->current_picture_ptr = &s->picture[i];
5472 // do parse frame header
5473 v->pic_header_flag = 0;
5474 if (v->profile < PROFILE_ADVANCED) {
5475 if (ff_vc1_parse_frame_header(v, &s->gb) == -1) {
5479 if (ff_vc1_parse_frame_header_adv(v, &s->gb) == -1) {
5484 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
5485 && s->pict_type != AV_PICTURE_TYPE_I) {
5486 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5490 // process pulldown flags
5491 s->current_picture_ptr->f.repeat_pict = 0;
5492 // Pulldown flags are only valid when 'broadcast' has been set.
5493 // So ticks_per_frame will be 2
5496 s->current_picture_ptr->f.repeat_pict = 1;
5497 } else if (v->rptfrm) {
5499 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5502 // for skipping the frame
5503 s->current_picture.f.pict_type = s->pict_type;
5504 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5506 /* skip B-frames if we don't have reference frames */
5507 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
5510 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5511 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5512 avctx->skip_frame >= AVDISCARD_ALL) {
5516 if (s->next_p_frame_damaged) {
5517 if (s->pict_type == AV_PICTURE_TYPE_B)
5520 s->next_p_frame_damaged = 0;
5523 if (ff_MPV_frame_start(s, avctx) < 0) {
5527 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5528 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5530 if ((CONFIG_VC1_VDPAU_DECODER)
5531 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5532 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5533 else if (avctx->hwaccel) {
5534 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
5536 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5538 if (avctx->hwaccel->end_frame(avctx) < 0)
5541 ff_er_frame_start(s);
5543 v->bits = buf_size * 8;
5544 if (v->field_mode) {
5546 s->current_picture.f.linesize[0] <<= 1;
5547 s->current_picture.f.linesize[1] <<= 1;
5548 s->current_picture.f.linesize[2] <<= 1;
5550 s->uvlinesize <<= 1;
5551 tmp[0] = v->mv_f_last[0];
5552 tmp[1] = v->mv_f_last[1];
5553 v->mv_f_last[0] = v->mv_f_next[0];
5554 v->mv_f_last[1] = v->mv_f_next[1];
5555 v->mv_f_next[0] = v->mv_f[0];
5556 v->mv_f_next[1] = v->mv_f[1];
5557 v->mv_f[0] = tmp[0];
5558 v->mv_f[1] = tmp[1];
5560 mb_height = s->mb_height >> v->field_mode;
5561 for (i = 0; i <= n_slices; i++) {
5562 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5563 v->second_field = 1;
5564 v->blocks_off = s->mb_width * s->mb_height << 1;
5565 v->mb_off = s->mb_stride * s->mb_height >> 1;
5567 v->second_field = 0;
5572 v->pic_header_flag = 0;
5573 if (v->field_mode && i == n_slices1 + 2)
5574 ff_vc1_parse_frame_header_adv(v, &s->gb);
5575 else if (get_bits1(&s->gb)) {
5576 v->pic_header_flag = 1;
5577 ff_vc1_parse_frame_header_adv(v, &s->gb);
5580 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5581 if (!v->field_mode || v->second_field)
5582 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5584 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5585 vc1_decode_blocks(v);
5587 s->gb = slices[i].gb;
5589 if (v->field_mode) {
5590 v->second_field = 0;
5591 if (s->pict_type == AV_PICTURE_TYPE_B) {
5592 memcpy(v->mv_f_base, v->mv_f_next_base,
5593 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5595 s->current_picture.f.linesize[0] >>= 1;
5596 s->current_picture.f.linesize[1] >>= 1;
5597 s->current_picture.f.linesize[2] >>= 1;
5599 s->uvlinesize >>= 1;
5601 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
5602 // if (get_bits_count(&s->gb) > buf_size * 8)
5604 if(s->error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
5609 ff_MPV_frame_end(s);
5611 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5613 avctx->width = avctx->coded_width = v->output_width;
5614 avctx->height = avctx->coded_height = v->output_height;
5615 if (avctx->skip_frame >= AVDISCARD_NONREF)
5617 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5618 if (vc1_decode_sprites(v, &s->gb))
5621 *pict = v->sprite_output_frame;
5622 *data_size = sizeof(AVFrame);
5624 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5625 *pict = s->current_picture_ptr->f;
5626 } else if (s->last_picture_ptr != NULL) {
5627 *pict = s->last_picture_ptr->f;
5629 if (s->last_picture_ptr || s->low_delay) {
5630 *data_size = sizeof(AVFrame);
5631 ff_print_debug_info(s, pict);
5637 for (i = 0; i < n_slices; i++)
5638 av_free(slices[i].buf);
5644 for (i = 0; i < n_slices; i++)
5645 av_free(slices[i].buf);
5651 static const AVProfile profiles[] = {
5652 { FF_PROFILE_VC1_SIMPLE, "Simple" },
5653 { FF_PROFILE_VC1_MAIN, "Main" },
5654 { FF_PROFILE_VC1_COMPLEX, "Complex" },
5655 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5656 { FF_PROFILE_UNKNOWN },
5659 AVCodec ff_vc1_decoder = {
5661 .type = AVMEDIA_TYPE_VIDEO,
5663 .priv_data_size = sizeof(VC1Context),
5664 .init = vc1_decode_init,
5665 .close = vc1_decode_end,
5666 .decode = vc1_decode_frame,
5667 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5668 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5669 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5670 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5673 #if CONFIG_WMV3_DECODER
5674 AVCodec ff_wmv3_decoder = {
5676 .type = AVMEDIA_TYPE_VIDEO,
5677 .id = CODEC_ID_WMV3,
5678 .priv_data_size = sizeof(VC1Context),
5679 .init = vc1_decode_init,
5680 .close = vc1_decode_end,
5681 .decode = vc1_decode_frame,
5682 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5683 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5684 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5685 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5689 #if CONFIG_WMV3_VDPAU_DECODER
5690 AVCodec ff_wmv3_vdpau_decoder = {
5691 .name = "wmv3_vdpau",
5692 .type = AVMEDIA_TYPE_VIDEO,
5693 .id = CODEC_ID_WMV3,
5694 .priv_data_size = sizeof(VC1Context),
5695 .init = vc1_decode_init,
5696 .close = vc1_decode_end,
5697 .decode = vc1_decode_frame,
5698 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5699 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5700 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE},
5701 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5705 #if CONFIG_VC1_VDPAU_DECODER
5706 AVCodec ff_vc1_vdpau_decoder = {
5707 .name = "vc1_vdpau",
5708 .type = AVMEDIA_TYPE_VIDEO,
5710 .priv_data_size = sizeof(VC1Context),
5711 .init = vc1_decode_init,
5712 .close = vc1_decode_end,
5713 .decode = vc1_decode_frame,
5714 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5715 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5716 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE},
5717 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5721 #if CONFIG_WMV3IMAGE_DECODER
5722 AVCodec ff_wmv3image_decoder = {
5723 .name = "wmv3image",
5724 .type = AVMEDIA_TYPE_VIDEO,
5725 .id = CODEC_ID_WMV3IMAGE,
5726 .priv_data_size = sizeof(VC1Context),
5727 .init = vc1_decode_init,
5728 .close = vc1_decode_end,
5729 .decode = vc1_decode_frame,
5730 .capabilities = CODEC_CAP_DR1,
5731 .flush = vc1_sprite_flush,
5732 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5733 .pix_fmts = ff_pixfmt_list_420
5737 #if CONFIG_VC1IMAGE_DECODER
5738 AVCodec ff_vc1image_decoder = {
5740 .type = AVMEDIA_TYPE_VIDEO,
5741 .id = CODEC_ID_VC1IMAGE,
5742 .priv_data_size = sizeof(VC1Context),
5743 .init = vc1_decode_init,
5744 .close = vc1_decode_end,
5745 .decode = vc1_decode_frame,
5746 .capabilities = CODEC_CAP_DR1,
5747 .flush = vc1_sprite_flush,
5748 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5749 .pix_fmts = ff_pixfmt_list_420