2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2011 Mashiat Sarker Shakkhar
4 * Copyright (c) 2006-2007 Konstantin Shishkov
5 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
7 * This file is part of Libav.
9 * Libav is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * Libav is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with Libav; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
32 #include "mpegvideo.h"
36 #include "vc1acdata.h"
37 #include "msmpeg4data.h"
39 #include "simple_idct.h"
41 #include "vdpau_internal.h"
46 #define MB_INTRA_VLC_BITS 9
51 static const uint16_t vlc_offs[] = {
52 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
53 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8342,
54 9304, 9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
55 20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
56 27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
57 29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
58 31714, 31746, 31778, 32306, 32340, 32372
61 // offset tables for interlaced picture MVDATA decoding
62 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
63 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
66 * Init VC-1 specific tables and VC1Context members
67 * @param v The VC1Context to initialize
70 static int vc1_init_common(VC1Context *v)
74 static VLC_TYPE vlc_table[32372][2];
76 v->hrd_rate = v->hrd_buffer = NULL;
80 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
81 ff_vc1_bfraction_bits, 1, 1,
82 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
83 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
84 ff_vc1_norm2_bits, 1, 1,
85 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
86 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
87 ff_vc1_norm6_bits, 1, 1,
88 ff_vc1_norm6_codes, 2, 2, 556);
89 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
90 ff_vc1_imode_bits, 1, 1,
91 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
92 for (i = 0; i < 3; i++) {
93 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 0]];
94 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
95 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
96 ff_vc1_ttmb_bits[i], 1, 1,
97 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
98 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 1]];
99 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
100 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
101 ff_vc1_ttblk_bits[i], 1, 1,
102 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
103 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 2]];
104 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
105 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
106 ff_vc1_subblkpat_bits[i], 1, 1,
107 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
109 for (i = 0; i < 4; i++) {
110 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 9]];
111 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
112 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
113 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
114 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
115 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 10]];
116 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
117 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
118 ff_vc1_cbpcy_p_bits[i], 1, 1,
119 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
120 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 11]];
121 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
122 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
123 ff_vc1_mv_diff_bits[i], 1, 1,
124 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
126 for (i = 0; i < 8; i++) {
127 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i * 2 + 21]];
128 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
129 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
130 &vc1_ac_tables[i][0][1], 8, 4,
131 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
132 /* initialize interlaced MVDATA tables (2-Ref) */
133 ff_vc1_2ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 2 + 22]];
134 ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
135 init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
136 ff_vc1_2ref_mvdata_bits[i], 1, 1,
137 ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
139 for (i = 0; i < 4; i++) {
140 /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
141 ff_vc1_intfr_4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 37]];
142 ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
143 init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
144 ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
145 ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
146 /* initialize NON-4MV MBMODE VLC tables for the same */
147 ff_vc1_intfr_non4mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 38]];
148 ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
149 init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
150 ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
151 ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
152 /* initialize interlaced MVDATA tables (1-Ref) */
153 ff_vc1_1ref_mvdata_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 39]];
154 ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
155 init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
156 ff_vc1_1ref_mvdata_bits[i], 1, 1,
157 ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
159 for (i = 0; i < 4; i++) {
160 /* Initialize 2MV Block pattern VLC tables */
161 ff_vc1_2mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i + 49]];
162 ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
163 init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
164 ff_vc1_2mv_block_pattern_bits[i], 1, 1,
165 ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
167 for (i = 0; i < 8; i++) {
168 /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
169 ff_vc1_icbpcy_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 53]];
170 ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
171 init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
172 ff_vc1_icbpcy_p_bits[i], 1, 1,
173 ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
174 /* Initialize interlaced field picture MBMODE VLC tables */
175 ff_vc1_if_mmv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 54]];
176 ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
177 init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
178 ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
179 ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
180 ff_vc1_if_1mv_mbmode_vlc[i].table = &vlc_table[vlc_offs[i * 3 + 55]];
181 ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
182 init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
183 ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
184 ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
191 v->mvrange = 0; /* 7.1.1.18, p80 */
196 /***********************************************************************/
198 * @name VC-1 Bitplane decoding
216 /** @} */ //imode defines
219 /** @} */ //Bitplane group
221 static void vc1_put_signed_blocks_clamped(VC1Context *v)
223 MpegEncContext *s = &v->s;
224 int topleft_mb_pos, top_mb_pos;
225 int stride_y, fieldtx;
228 /* The put pixels loop is always one MB row behind the decoding loop,
229 * because we can only put pixels when overlap filtering is done, and
230 * for filtering of the bottom edge of a MB, we need the next MB row
232 * Within the row, the put pixels loop is also one MB col behind the
233 * decoding loop. The reason for this is again, because for filtering
234 * of the right MB edge, we need the next MB present. */
235 if (!s->first_slice_line) {
237 topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
238 fieldtx = v->fieldtx_plane[topleft_mb_pos];
239 stride_y = (s->linesize) << fieldtx;
240 v_dist = (16 - fieldtx) >> (fieldtx == 0);
241 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
242 s->dest[0] - 16 * s->linesize - 16,
244 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
245 s->dest[0] - 16 * s->linesize - 8,
247 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
248 s->dest[0] - v_dist * s->linesize - 16,
250 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
251 s->dest[0] - v_dist * s->linesize - 8,
253 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
254 s->dest[1] - 8 * s->uvlinesize - 8,
256 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
257 s->dest[2] - 8 * s->uvlinesize - 8,
260 if (s->mb_x == s->mb_width - 1) {
261 top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
262 fieldtx = v->fieldtx_plane[top_mb_pos];
263 stride_y = s->linesize << fieldtx;
264 v_dist = fieldtx ? 15 : 8;
265 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
266 s->dest[0] - 16 * s->linesize,
268 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
269 s->dest[0] - 16 * s->linesize + 8,
271 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
272 s->dest[0] - v_dist * s->linesize,
274 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
275 s->dest[0] - v_dist * s->linesize + 8,
277 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
278 s->dest[1] - 8 * s->uvlinesize,
280 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
281 s->dest[2] - 8 * s->uvlinesize,
286 #define inc_blk_idx(idx) do { \
288 if (idx >= v->n_allocated_blks) \
292 inc_blk_idx(v->topleft_blk_idx);
293 inc_blk_idx(v->top_blk_idx);
294 inc_blk_idx(v->left_blk_idx);
295 inc_blk_idx(v->cur_blk_idx);
298 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
300 MpegEncContext *s = &v->s;
302 if (!s->first_slice_line) {
303 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
305 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
306 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
307 for (j = 0; j < 2; j++) {
308 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
310 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
313 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
315 if (s->mb_y == s->end_mb_y - 1) {
317 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
318 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
319 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
321 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
325 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
327 MpegEncContext *s = &v->s;
330 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
331 * means it runs two rows/cols behind the decoding loop. */
332 if (!s->first_slice_line) {
334 if (s->mb_y >= s->start_mb_y + 2) {
335 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
338 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
339 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
340 for (j = 0; j < 2; j++) {
341 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
343 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
347 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
350 if (s->mb_x == s->mb_width - 1) {
351 if (s->mb_y >= s->start_mb_y + 2) {
352 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
355 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
356 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
357 for (j = 0; j < 2; j++) {
358 v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
360 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
364 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
367 if (s->mb_y == s->end_mb_y) {
370 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
371 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
373 for (j = 0; j < 2; j++) {
374 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
379 if (s->mb_x == s->mb_width - 1) {
381 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
382 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
384 for (j = 0; j < 2; j++) {
385 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
393 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
395 MpegEncContext *s = &v->s;
398 if (v->condover == CONDOVER_NONE)
401 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
403 /* Within a MB, the horizontal overlap always runs before the vertical.
404 * To accomplish that, we run the H on left and internal borders of the
405 * currently decoded MB. Then, we wait for the next overlap iteration
406 * to do H overlap on the right edge of this MB, before moving over and
407 * running the V overlap. Therefore, the V overlap makes us trail by one
408 * MB col and the H overlap filter makes us trail by one MB row. This
409 * is reflected in the time at which we run the put_pixels loop. */
410 if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
411 if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
412 v->over_flags_plane[mb_pos - 1])) {
413 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
414 v->block[v->cur_blk_idx][0]);
415 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
416 v->block[v->cur_blk_idx][2]);
417 if (!(s->flags & CODEC_FLAG_GRAY)) {
418 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
419 v->block[v->cur_blk_idx][4]);
420 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
421 v->block[v->cur_blk_idx][5]);
424 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
425 v->block[v->cur_blk_idx][1]);
426 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
427 v->block[v->cur_blk_idx][3]);
429 if (s->mb_x == s->mb_width - 1) {
430 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
431 v->over_flags_plane[mb_pos - s->mb_stride])) {
432 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
433 v->block[v->cur_blk_idx][0]);
434 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
435 v->block[v->cur_blk_idx][1]);
436 if (!(s->flags & CODEC_FLAG_GRAY)) {
437 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
438 v->block[v->cur_blk_idx][4]);
439 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
440 v->block[v->cur_blk_idx][5]);
443 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
444 v->block[v->cur_blk_idx][2]);
445 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
446 v->block[v->cur_blk_idx][3]);
449 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
450 if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
451 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
452 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
453 v->block[v->left_blk_idx][0]);
454 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
455 v->block[v->left_blk_idx][1]);
456 if (!(s->flags & CODEC_FLAG_GRAY)) {
457 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
458 v->block[v->left_blk_idx][4]);
459 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
460 v->block[v->left_blk_idx][5]);
463 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
464 v->block[v->left_blk_idx][2]);
465 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
466 v->block[v->left_blk_idx][3]);
470 /** Do motion compensation over 1 macroblock
471 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
473 static void vc1_mc_1mv(VC1Context *v, int dir)
475 MpegEncContext *s = &v->s;
476 DSPContext *dsp = &v->s.dsp;
477 uint8_t *srcY, *srcU, *srcV;
478 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
480 int v_edge_pos = s->v_edge_pos >> v->field_mode;
481 if (!v->field_mode && !v->s.last_picture.f.data[0])
484 mx = s->mv[dir][0][0];
485 my = s->mv[dir][0][1];
487 // store motion vectors for further use in B frames
488 if (s->pict_type == AV_PICTURE_TYPE_P) {
489 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
490 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
493 uvmx = (mx + ((mx & 3) == 3)) >> 1;
494 uvmy = (my + ((my & 3) == 3)) >> 1;
495 v->luma_mv[s->mb_x][0] = uvmx;
496 v->luma_mv[s->mb_x][1] = uvmy;
499 v->cur_field_type != v->ref_field_type[dir]) {
500 my = my - 2 + 4 * v->cur_field_type;
501 uvmy = uvmy - 2 + 4 * v->cur_field_type;
504 if (v->fastuvmc && (v->fcm != 1)) { // fastuvmc shall be ignored for interlaced frame picture
505 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
506 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
508 if (v->field_mode) { // interlaced field picture
510 if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type) {
511 srcY = s->current_picture.f.data[0];
512 srcU = s->current_picture.f.data[1];
513 srcV = s->current_picture.f.data[2];
515 srcY = s->last_picture.f.data[0];
516 srcU = s->last_picture.f.data[1];
517 srcV = s->last_picture.f.data[2];
520 srcY = s->next_picture.f.data[0];
521 srcU = s->next_picture.f.data[1];
522 srcV = s->next_picture.f.data[2];
526 srcY = s->last_picture.f.data[0];
527 srcU = s->last_picture.f.data[1];
528 srcV = s->last_picture.f.data[2];
530 srcY = s->next_picture.f.data[0];
531 srcU = s->next_picture.f.data[1];
532 srcV = s->next_picture.f.data[2];
536 src_x = s->mb_x * 16 + (mx >> 2);
537 src_y = s->mb_y * 16 + (my >> 2);
538 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
539 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
541 if (v->profile != PROFILE_ADVANCED) {
542 src_x = av_clip( src_x, -16, s->mb_width * 16);
543 src_y = av_clip( src_y, -16, s->mb_height * 16);
544 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
545 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
547 src_x = av_clip( src_x, -17, s->avctx->coded_width);
548 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
549 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
550 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
553 srcY += src_y * s->linesize + src_x;
554 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
555 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
557 if (v->field_mode && v->ref_field_type[dir]) {
558 srcY += s->current_picture_ptr->f.linesize[0];
559 srcU += s->current_picture_ptr->f.linesize[1];
560 srcV += s->current_picture_ptr->f.linesize[2];
563 /* for grayscale we should not try to read from unknown area */
564 if (s->flags & CODEC_FLAG_GRAY) {
565 srcU = s->edge_emu_buffer + 18 * s->linesize;
566 srcV = s->edge_emu_buffer + 18 * s->linesize;
569 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
570 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
571 || (unsigned)(src_y - s->mspel) > v_edge_pos - (my&3) - 16 - s->mspel * 3) {
572 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
574 srcY -= s->mspel * (1 + s->linesize);
575 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
576 17 + s->mspel * 2, 17 + s->mspel * 2,
577 src_x - s->mspel, src_y - s->mspel,
578 s->h_edge_pos, v_edge_pos);
579 srcY = s->edge_emu_buffer;
580 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
581 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
582 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
583 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
586 /* if we deal with range reduction we need to scale source blocks */
587 if (v->rangeredfrm) {
592 for (j = 0; j < 17 + s->mspel * 2; j++) {
593 for (i = 0; i < 17 + s->mspel * 2; i++)
594 src[i] = ((src[i] - 128) >> 1) + 128;
599 for (j = 0; j < 9; j++) {
600 for (i = 0; i < 9; i++) {
601 src[i] = ((src[i] - 128) >> 1) + 128;
602 src2[i] = ((src2[i] - 128) >> 1) + 128;
604 src += s->uvlinesize;
605 src2 += s->uvlinesize;
608 /* if we deal with intensity compensation we need to scale source blocks */
609 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
614 for (j = 0; j < 17 + s->mspel * 2; j++) {
615 for (i = 0; i < 17 + s->mspel * 2; i++)
616 src[i] = v->luty[src[i]];
621 for (j = 0; j < 9; j++) {
622 for (i = 0; i < 9; i++) {
623 src[i] = v->lutuv[src[i]];
624 src2[i] = v->lutuv[src2[i]];
626 src += s->uvlinesize;
627 src2 += s->uvlinesize;
630 srcY += s->mspel * (1 + s->linesize);
633 if (v->field_mode && v->cur_field_type) {
634 off = s->current_picture_ptr->f.linesize[0];
635 off_uv = s->current_picture_ptr->f.linesize[1];
641 dxy = ((my & 3) << 2) | (mx & 3);
642 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
643 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
644 srcY += s->linesize * 8;
645 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
646 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
647 } else { // hpel mc - always used for luma
648 dxy = (my & 2) | ((mx & 2) >> 1);
650 dsp->put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
652 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
655 if (s->flags & CODEC_FLAG_GRAY) return;
656 /* Chroma MC always uses qpel bilinear */
657 uvmx = (uvmx & 3) << 1;
658 uvmy = (uvmy & 3) << 1;
660 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
661 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
663 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
664 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
668 static inline int median4(int a, int b, int c, int d)
671 if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
672 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
674 if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
675 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
679 /** Do motion compensation for 4-MV macroblock - luminance block
681 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
683 MpegEncContext *s = &v->s;
684 DSPContext *dsp = &v->s.dsp;
686 int dxy, mx, my, src_x, src_y;
688 int fieldmv = (v->fcm == 1) ? v->blk_mv_type[s->block_index[n]] : 0;
689 int v_edge_pos = s->v_edge_pos >> v->field_mode;
691 if (!v->field_mode && !v->s.last_picture.f.data[0])
694 mx = s->mv[dir][n][0];
695 my = s->mv[dir][n][1];
699 if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type)
700 srcY = s->current_picture.f.data[0];
702 srcY = s->last_picture.f.data[0];
704 srcY = s->last_picture.f.data[0];
706 srcY = s->next_picture.f.data[0];
709 if (v->cur_field_type != v->ref_field_type[dir])
710 my = my - 2 + 4 * v->cur_field_type;
713 if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
714 int same_count = 0, opp_count = 0, k;
715 int chosen_mv[2][4][2], f;
717 for (k = 0; k < 4; k++) {
718 f = v->mv_f[0][s->block_index[k] + v->blocks_off];
719 chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
720 chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
724 f = opp_count > same_count;
725 switch (f ? opp_count : same_count) {
727 tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
728 chosen_mv[f][2][0], chosen_mv[f][3][0]);
729 ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
730 chosen_mv[f][2][1], chosen_mv[f][3][1]);
733 tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
734 ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
737 tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
738 ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
741 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
742 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
743 for (k = 0; k < 4; k++)
744 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
747 if (v->fcm == 1) { // not sure if needed for other types of picture
749 int width = s->avctx->coded_width;
750 int height = s->avctx->coded_height >> 1;
751 qx = (s->mb_x * 16) + (mx >> 2);
752 qy = (s->mb_y * 8) + (my >> 3);
757 mx -= 4 * (qx - width);
760 else if (qy > height + 1)
761 my -= 8 * (qy - height - 1);
764 if ((v->fcm == 1) && fieldmv)
765 off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
767 off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
768 if (v->field_mode && v->cur_field_type)
769 off += s->current_picture_ptr->f.linesize[0];
771 src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
773 src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
775 src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
777 if (v->profile != PROFILE_ADVANCED) {
778 src_x = av_clip(src_x, -16, s->mb_width * 16);
779 src_y = av_clip(src_y, -16, s->mb_height * 16);
781 src_x = av_clip(src_x, -17, s->avctx->coded_width);
784 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
786 src_y = av_clip(src_y, -18, s->avctx->coded_height);
788 src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
792 srcY += src_y * s->linesize + src_x;
793 if (v->field_mode && v->ref_field_type[dir])
794 srcY += s->current_picture_ptr->f.linesize[0];
796 if (fieldmv && !(src_y & 1))
798 if (fieldmv && (src_y & 1) && src_y < 4)
800 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
801 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
802 || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
803 srcY -= s->mspel * (1 + (s->linesize << fieldmv));
804 /* check emulate edge stride and offset */
805 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
806 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
807 src_x - s->mspel, src_y - (s->mspel << fieldmv),
808 s->h_edge_pos, v_edge_pos);
809 srcY = s->edge_emu_buffer;
810 /* if we deal with range reduction we need to scale source blocks */
811 if (v->rangeredfrm) {
816 for (j = 0; j < 9 + s->mspel * 2; j++) {
817 for (i = 0; i < 9 + s->mspel * 2; i++)
818 src[i] = ((src[i] - 128) >> 1) + 128;
819 src += s->linesize << fieldmv;
822 /* if we deal with intensity compensation we need to scale source blocks */
823 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
828 for (j = 0; j < 9 + s->mspel * 2; j++) {
829 for (i = 0; i < 9 + s->mspel * 2; i++)
830 src[i] = v->luty[src[i]];
831 src += s->linesize << fieldmv;
834 srcY += s->mspel * (1 + (s->linesize << fieldmv));
838 dxy = ((my & 3) << 2) | (mx & 3);
839 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
840 } else { // hpel mc - always used for luma
841 dxy = (my & 2) | ((mx & 2) >> 1);
843 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
845 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
849 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
852 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
854 idx = ((a[3] != flag) << 3)
855 | ((a[2] != flag) << 2)
856 | ((a[1] != flag) << 1)
859 *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
860 *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
862 } else if (count[idx] == 1) {
865 *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
866 *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
869 *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
870 *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
873 *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
874 *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
877 *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
878 *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
881 } else if (count[idx] == 2) {
883 for (i = 0; i < 3; i++)
888 for (i = t1 + 1; i < 4; i++)
893 *tx = (mvx[t1] + mvx[t2]) / 2;
894 *ty = (mvy[t1] + mvy[t2]) / 2;
902 /** Do motion compensation for 4-MV macroblock - both chroma blocks
904 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
906 MpegEncContext *s = &v->s;
907 DSPContext *dsp = &v->s.dsp;
908 uint8_t *srcU, *srcV;
909 int uvmx, uvmy, uvsrc_x, uvsrc_y;
910 int k, tx = 0, ty = 0;
911 int mvx[4], mvy[4], intra[4], mv_f[4];
913 int chroma_ref_type = v->cur_field_type, off = 0;
914 int v_edge_pos = s->v_edge_pos >> v->field_mode;
916 if (!v->field_mode && !v->s.last_picture.f.data[0])
918 if (s->flags & CODEC_FLAG_GRAY)
921 for (k = 0; k < 4; k++) {
922 mvx[k] = s->mv[dir][k][0];
923 mvy[k] = s->mv[dir][k][1];
924 intra[k] = v->mb_type[0][s->block_index[k]];
926 mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
929 /* calculate chroma MV vector from four luma MVs */
930 if (!v->field_mode || (v->field_mode && !v->numref)) {
931 valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
933 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
934 return; //no need to do MC for intra blocks
938 if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
940 valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
942 chroma_ref_type = !v->cur_field_type;
944 uvmx = (tx + ((tx & 3) == 3)) >> 1;
945 uvmy = (ty + ((ty & 3) == 3)) >> 1;
947 v->luma_mv[s->mb_x][0] = uvmx;
948 v->luma_mv[s->mb_x][1] = uvmy;
951 uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
952 uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
954 // Field conversion bias
955 if (v->cur_field_type != chroma_ref_type)
956 uvmy += 2 - 4 * chroma_ref_type;
958 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
959 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
961 if (v->profile != PROFILE_ADVANCED) {
962 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
963 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
965 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
966 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
971 if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
972 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
973 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
975 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
976 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
979 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
980 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
983 srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
984 srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
988 if (chroma_ref_type) {
989 srcU += s->current_picture_ptr->f.linesize[1];
990 srcV += s->current_picture_ptr->f.linesize[2];
992 off = v->cur_field_type ? s->current_picture_ptr->f.linesize[1] : 0;
995 if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
996 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
997 || (unsigned)uvsrc_y > (v_edge_pos >> 1) - 9) {
998 s->dsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize,
999 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
1000 s->h_edge_pos >> 1, v_edge_pos >> 1);
1001 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
1002 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
1003 s->h_edge_pos >> 1, v_edge_pos >> 1);
1004 srcU = s->edge_emu_buffer;
1005 srcV = s->edge_emu_buffer + 16;
1007 /* if we deal with range reduction we need to scale source blocks */
1008 if (v->rangeredfrm) {
1010 uint8_t *src, *src2;
1014 for (j = 0; j < 9; j++) {
1015 for (i = 0; i < 9; i++) {
1016 src[i] = ((src[i] - 128) >> 1) + 128;
1017 src2[i] = ((src2[i] - 128) >> 1) + 128;
1019 src += s->uvlinesize;
1020 src2 += s->uvlinesize;
1023 /* if we deal with intensity compensation we need to scale source blocks */
1024 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1026 uint8_t *src, *src2;
1030 for (j = 0; j < 9; j++) {
1031 for (i = 0; i < 9; i++) {
1032 src[i] = v->lutuv[src[i]];
1033 src2[i] = v->lutuv[src2[i]];
1035 src += s->uvlinesize;
1036 src2 += s->uvlinesize;
1041 /* Chroma MC always uses qpel bilinear */
1042 uvmx = (uvmx & 3) << 1;
1043 uvmy = (uvmy & 3) << 1;
1045 dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
1046 dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
1048 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
1049 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
1053 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
1055 static void vc1_mc_4mv_chroma4(VC1Context *v)
1057 MpegEncContext *s = &v->s;
1058 DSPContext *dsp = &v->s.dsp;
1059 uint8_t *srcU, *srcV;
1060 int uvsrc_x, uvsrc_y;
1061 int uvmx_field[4], uvmy_field[4];
1063 int fieldmv = v->blk_mv_type[s->block_index[0]];
1064 static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
1065 int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
1066 int v_edge_pos = s->v_edge_pos >> 1;
1068 if (!v->s.last_picture.f.data[0])
1070 if (s->flags & CODEC_FLAG_GRAY)
1073 for (i = 0; i < 4; i++) {
1074 tx = s->mv[0][i][0];
1075 uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
1076 ty = s->mv[0][i][1];
1078 uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
1080 uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
1083 for (i = 0; i < 4; i++) {
1084 off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
1085 uvsrc_x = s->mb_x * 8 + (i & 1) * 4 + (uvmx_field[i] >> 2);
1086 uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
1087 // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
1088 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1089 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1090 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1091 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1092 uvmx_field[i] = (uvmx_field[i] & 3) << 1;
1093 uvmy_field[i] = (uvmy_field[i] & 3) << 1;
1095 if (fieldmv && !(uvsrc_y & 1))
1097 if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
1099 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
1100 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
1101 || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
1102 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
1103 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1104 s->h_edge_pos >> 1, v_edge_pos);
1105 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
1106 5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1107 s->h_edge_pos >> 1, v_edge_pos);
1108 srcU = s->edge_emu_buffer;
1109 srcV = s->edge_emu_buffer + 16;
1111 /* if we deal with intensity compensation we need to scale source blocks */
1112 if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1114 uint8_t *src, *src2;
1118 for (j = 0; j < 5; j++) {
1119 for (i = 0; i < 5; i++) {
1120 src[i] = v->lutuv[src[i]];
1121 src2[i] = v->lutuv[src2[i]];
1123 src += s->uvlinesize << 1;
1124 src2 += s->uvlinesize << 1;
1129 dsp->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1130 dsp->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1132 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]);
1133 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]);
1138 /***********************************************************************/
1140 * @name VC-1 Block-level functions
1141 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1147 * @brief Get macroblock-level quantizer scale
1149 #define GET_MQUANT() \
1150 if (v->dquantfrm) { \
1152 if (v->dqprofile == DQPROFILE_ALL_MBS) { \
1153 if (v->dqbilevel) { \
1154 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1156 mqdiff = get_bits(gb, 3); \
1158 mquant = v->pq + mqdiff; \
1160 mquant = get_bits(gb, 5); \
1163 if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1164 edges = 1 << v->dqsbedge; \
1165 else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1166 edges = (3 << v->dqsbedge) % 15; \
1167 else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
1169 if ((edges&1) && !s->mb_x) \
1170 mquant = v->altpq; \
1171 if ((edges&2) && s->first_slice_line) \
1172 mquant = v->altpq; \
1173 if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
1174 mquant = v->altpq; \
1175 if ((edges&8) && s->mb_y == (s->mb_height - 1)) \
1176 mquant = v->altpq; \
1180 * @def GET_MVDATA(_dmv_x, _dmv_y)
1181 * @brief Get MV differentials
1182 * @see MVDATA decoding from 8.3.5.2, p(1)20
1183 * @param _dmv_x Horizontal differential for decoded MV
1184 * @param _dmv_y Vertical differential for decoded MV
1186 #define GET_MVDATA(_dmv_x, _dmv_y) \
1187 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1188 VC1_MV_DIFF_VLC_BITS, 2); \
1190 mb_has_coeffs = 1; \
1193 mb_has_coeffs = 0; \
1196 _dmv_x = _dmv_y = 0; \
1197 } else if (index == 35) { \
1198 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1199 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1200 } else if (index == 36) { \
1205 index1 = index % 6; \
1206 if (!s->quarter_sample && index1 == 5) val = 1; \
1208 if (size_table[index1] - val > 0) \
1209 val = get_bits(gb, size_table[index1] - val); \
1211 sign = 0 - (val&1); \
1212 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1214 index1 = index / 6; \
1215 if (!s->quarter_sample && index1 == 5) val = 1; \
1217 if (size_table[index1] - val > 0) \
1218 val = get_bits(gb, size_table[index1] - val); \
1220 sign = 0 - (val & 1); \
1221 _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign; \
1224 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1225 int *dmv_y, int *pred_flag)
1228 int extend_x = 0, extend_y = 0;
1229 GetBitContext *gb = &v->s.gb;
1232 const int* offs_tab;
1235 bits = VC1_2REF_MVDATA_VLC_BITS;
1238 bits = VC1_1REF_MVDATA_VLC_BITS;
1241 switch (v->dmvrange) {
1249 extend_x = extend_y = 1;
1252 index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1254 *dmv_x = get_bits(gb, v->k_x);
1255 *dmv_y = get_bits(gb, v->k_y);
1257 *pred_flag = *dmv_y & 1;
1258 *dmv_y = (*dmv_y + *pred_flag) >> 1;
1263 offs_tab = offset_table2;
1265 offs_tab = offset_table1;
1266 index1 = (index + 1) % 9;
1268 val = get_bits(gb, index1 + extend_x);
1269 sign = 0 -(val & 1);
1270 *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1274 offs_tab = offset_table2;
1276 offs_tab = offset_table1;
1277 index1 = (index + 1) / 9;
1278 if (index1 > v->numref) {
1279 val = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1280 sign = 0 - (val & 1);
1281 *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1285 *pred_flag = index1 & 1;
1289 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1291 int scaledvalue, refdist;
1292 int scalesame1, scalesame2;
1293 int scalezone1_x, zone1offset_x;
1295 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1296 refdist = v->refdist;
1298 refdist = dir ? v->brfd : v->frfd;
1301 scalesame1 = vc1_field_mvpred_scales[v->second_field][1][refdist];
1302 scalesame2 = vc1_field_mvpred_scales[v->second_field][2][refdist];
1303 scalezone1_x = vc1_field_mvpred_scales[v->second_field][3][refdist];
1304 zone1offset_x = vc1_field_mvpred_scales[v->second_field][5][refdist];
1309 if (FFABS(n) < scalezone1_x)
1310 scaledvalue = (n * scalesame1) >> 8;
1313 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1315 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1318 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1321 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1323 int scaledvalue, refdist;
1324 int scalesame1, scalesame2;
1325 int scalezone1_y, zone1offset_y;
1327 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1328 refdist = v->refdist;
1330 refdist = dir ? v->brfd : v->frfd;
1333 scalesame1 = vc1_field_mvpred_scales[v->second_field][1][refdist];
1334 scalesame2 = vc1_field_mvpred_scales[v->second_field][2][refdist];
1335 scalezone1_y = vc1_field_mvpred_scales[v->second_field][4][refdist];
1336 zone1offset_y = vc1_field_mvpred_scales[v->second_field][6][refdist];
1341 if (FFABS(n) < scalezone1_y)
1342 scaledvalue = (n * scalesame1) >> 8;
1345 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1347 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1351 if (v->cur_field_type && !v->ref_field_type[dir])
1352 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1354 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1357 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1359 int scalezone1_x, zone1offset_x;
1360 int scaleopp1, scaleopp2, brfd;
1363 brfd = FFMIN(v->brfd, 3);
1364 scalezone1_x = vc1_b_field_mvpred_scales[3][brfd];
1365 zone1offset_x = vc1_b_field_mvpred_scales[5][brfd];
1366 scaleopp1 = vc1_b_field_mvpred_scales[1][brfd];
1367 scaleopp2 = vc1_b_field_mvpred_scales[2][brfd];
1372 if (FFABS(n) < scalezone1_x)
1373 scaledvalue = (n * scaleopp1) >> 8;
1376 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1378 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1381 return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1384 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1386 int scalezone1_y, zone1offset_y;
1387 int scaleopp1, scaleopp2, brfd;
1390 brfd = FFMIN(v->brfd, 3);
1391 scalezone1_y = vc1_b_field_mvpred_scales[4][brfd];
1392 zone1offset_y = vc1_b_field_mvpred_scales[6][brfd];
1393 scaleopp1 = vc1_b_field_mvpred_scales[1][brfd];
1394 scaleopp2 = vc1_b_field_mvpred_scales[2][brfd];
1399 if (FFABS(n) < scalezone1_y)
1400 scaledvalue = (n * scaleopp1) >> 8;
1403 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1405 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1408 if (v->cur_field_type && !v->ref_field_type[dir]) {
1409 return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1411 return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1415 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1418 int brfd, scalesame;
1420 if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1422 return scaleforsame_y(v, i, n, dir);
1424 return scaleforsame_x(v, n, dir);
1426 brfd = FFMIN(v->brfd, 3);
1427 scalesame = vc1_b_field_mvpred_scales[0][brfd];
1429 return n * scalesame >> 8;
1432 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1435 int refdist, scaleopp;
1437 if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1439 return scaleforopp_y(v, n, dir);
1441 return scaleforopp_x(v, n);
1443 if (v->s.pict_type != AV_PICTURE_TYPE_B)
1444 refdist = FFMIN(v->refdist, 3);
1446 refdist = dir ? v->brfd : v->frfd;
1447 scaleopp = vc1_field_mvpred_scales[v->second_field][0][refdist];
1449 return n * scaleopp >> 8;
1452 /** Predict and set motion vector
1454 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1455 int mv1, int r_x, int r_y, uint8_t* is_intra,
1456 int pred_flag, int dir)
1458 MpegEncContext *s = &v->s;
1459 int xy, wrap, off = 0;
1463 int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1465 int16_t samefield_pred[2], oppfield_pred[2];
1466 int16_t samefield_predA[2], oppfield_predA[2];
1467 int16_t samefield_predB[2], oppfield_predB[2];
1468 int16_t samefield_predC[2], oppfield_predC[2];
1469 int16_t *predA, *predC;
1470 int a_valid, b_valid, c_valid;
1471 int hybridmv_thresh, y_bias = 0;
1473 if (v->mv_mode == MV_PMODE_MIXED_MV ||
1474 ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1478 /* scale MV difference to be quad-pel */
1479 dmv_x <<= 1 - s->quarter_sample;
1480 dmv_y <<= 1 - s->quarter_sample;
1482 wrap = s->b8_stride;
1483 xy = s->block_index[n];
1486 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
1487 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
1488 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
1489 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
1490 if (mv1) { /* duplicate motion data for 1-MV block */
1491 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0] = 0;
1492 s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1] = 0;
1493 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0] = 0;
1494 s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1] = 0;
1495 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1496 s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1497 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1498 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0] = 0;
1499 s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1] = 0;
1500 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1501 s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1] = 0;
1502 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1503 s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1508 C = s->current_picture.f.motion_val[dir][xy - 1 + v->blocks_off];
1509 A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
1511 if (v->field_mode && mixedmv_pic)
1512 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1514 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1516 //in 4-MV mode different blocks have different B predictor position
1519 off = (s->mb_x > 0) ? -1 : 1;
1522 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1531 B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
1533 a_valid = !s->first_slice_line || (n == 2 || n == 3);
1534 b_valid = a_valid && (s->mb_width > 1);
1535 c_valid = s->mb_x || (n == 1 || n == 3);
1536 if (v->field_mode) {
1537 a_valid = a_valid && !is_intra[xy - wrap];
1538 b_valid = b_valid && !is_intra[xy - wrap + off];
1539 c_valid = c_valid && !is_intra[xy - 1];
1543 f = v->mv_f[dir][xy - wrap + v->blocks_off];
1545 num_samefield += 1 - f;
1547 oppfield_predA[0] = A[0];
1548 oppfield_predA[1] = A[1];
1549 samefield_predA[0] = scaleforsame(v, 0, A[0], 0, dir);
1550 samefield_predA[1] = scaleforsame(v, n, A[1], 1, dir);
1552 samefield_predA[0] = A[0];
1553 samefield_predA[1] = A[1];
1555 oppfield_predA[0] = scaleforopp(v, A[0], 0, dir);
1557 oppfield_predA[1] = scaleforopp(v, A[1], 1, dir);
1560 samefield_predA[0] = samefield_predA[1] = 0;
1561 oppfield_predA[0] = oppfield_predA[1] = 0;
1564 f = v->mv_f[dir][xy - 1 + v->blocks_off];
1566 num_samefield += 1 - f;
1568 oppfield_predC[0] = C[0];
1569 oppfield_predC[1] = C[1];
1570 samefield_predC[0] = scaleforsame(v, 0, C[0], 0, dir);
1571 samefield_predC[1] = scaleforsame(v, n, C[1], 1, dir);
1573 samefield_predC[0] = C[0];
1574 samefield_predC[1] = C[1];
1576 oppfield_predC[0] = scaleforopp(v, C[0], 0, dir);
1578 oppfield_predC[1] = scaleforopp(v, C[1], 1, dir);
1581 samefield_predC[0] = samefield_predC[1] = 0;
1582 oppfield_predC[0] = oppfield_predC[1] = 0;
1585 f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1587 num_samefield += 1 - f;
1589 oppfield_predB[0] = B[0];
1590 oppfield_predB[1] = B[1];
1591 samefield_predB[0] = scaleforsame(v, 0, B[0], 0, dir);
1592 samefield_predB[1] = scaleforsame(v, n, B[1], 1, dir);
1594 samefield_predB[0] = B[0];
1595 samefield_predB[1] = B[1];
1597 oppfield_predB[0] = scaleforopp(v, B[0], 0, dir);
1599 oppfield_predB[1] = scaleforopp(v, B[1], 1, dir);
1602 samefield_predB[0] = samefield_predB[1] = 0;
1603 oppfield_predB[0] = oppfield_predB[1] = 0;
1607 samefield_pred[0] = samefield_predA[0];
1608 samefield_pred[1] = samefield_predA[1];
1609 oppfield_pred[0] = oppfield_predA[0];
1610 oppfield_pred[1] = oppfield_predA[1];
1611 } else if (c_valid) {
1612 samefield_pred[0] = samefield_predC[0];
1613 samefield_pred[1] = samefield_predC[1];
1614 oppfield_pred[0] = oppfield_predC[0];
1615 oppfield_pred[1] = oppfield_predC[1];
1616 } else if (b_valid) {
1617 samefield_pred[0] = samefield_predB[0];
1618 samefield_pred[1] = samefield_predB[1];
1619 oppfield_pred[0] = oppfield_predB[0];
1620 oppfield_pred[1] = oppfield_predB[1];
1622 samefield_pred[0] = samefield_pred[1] = 0;
1623 oppfield_pred[0] = oppfield_pred[1] = 0;
1626 if (num_samefield + num_oppfield > 1) {
1627 samefield_pred[0] = mid_pred(samefield_predA[0], samefield_predB[0], samefield_predC[0]);
1628 samefield_pred[1] = mid_pred(samefield_predA[1], samefield_predB[1], samefield_predC[1]);
1630 oppfield_pred[0] = mid_pred(oppfield_predA[0], oppfield_predB[0], oppfield_predC[0]);
1632 oppfield_pred[1] = mid_pred(oppfield_predA[1], oppfield_predB[1], oppfield_predC[1]);
1635 if (v->field_mode) {
1636 if (num_samefield <= num_oppfield)
1637 opposit = 1 - pred_flag;
1639 opposit = pred_flag;
1643 px = oppfield_pred[0];
1644 py = oppfield_pred[1];
1645 predA = oppfield_predA;
1646 predC = oppfield_predC;
1647 v->mv_f[dir][xy + v->blocks_off] = f = 1;
1648 v->ref_field_type[dir] = !v->cur_field_type;
1650 px = samefield_pred[0];
1651 py = samefield_pred[1];
1652 predA = samefield_predA;
1653 predC = samefield_predC;
1654 v->mv_f[dir][xy + v->blocks_off] = f = 0;
1655 v->ref_field_type[dir] = v->cur_field_type;
1658 /* Pullback MV as specified in 8.3.5.3.4 */
1659 if (!v->field_mode) {
1661 qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1662 qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1663 X = (s->mb_width << 6) - 4;
1664 Y = (s->mb_height << 6) - 4;
1666 if (qx + px < -60) px = -60 - qx;
1667 if (qy + py < -60) py = -60 - qy;
1669 if (qx + px < -28) px = -28 - qx;
1670 if (qy + py < -28) py = -28 - qy;
1672 if (qx + px > X) px = X - qx;
1673 if (qy + py > Y) py = Y - qy;
1676 if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1677 /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1678 if (v->field_mode && !s->quarter_sample)
1679 hybridmv_thresh = 16;
1681 hybridmv_thresh = 32;
1682 if (a_valid && c_valid) {
1683 if (is_intra[xy - wrap])
1684 sum = FFABS(px) + FFABS(py);
1686 sum = FFABS(px - predA[0]) + FFABS(py - predA[1]);
1687 if (sum > hybridmv_thresh) {
1688 if (get_bits1(&s->gb)) { // read HYBRIDPRED bit
1696 if (is_intra[xy - 1])
1697 sum = FFABS(px) + FFABS(py);
1699 sum = FFABS(px - predC[0]) + FFABS(py - predC[1]);
1700 if (sum > hybridmv_thresh) {
1701 if (get_bits1(&s->gb)) {
1713 if (v->field_mode && !s->quarter_sample) {
1717 if (v->field_mode && v->numref)
1719 if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1721 /* store MV using signed modulus of MV range defined in 4.11 */
1722 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;
1723 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;
1724 if (mv1) { /* duplicate motion data for 1-MV block */
1725 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];
1726 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];
1727 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];
1728 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];
1729 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];
1730 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];
1731 v->mv_f[dir][xy + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
1732 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];
1736 /** Predict and set motion vector for interlaced frame picture MBs
1738 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1739 int mvn, int r_x, int r_y, uint8_t* is_intra)
1741 MpegEncContext *s = &v->s;
1742 int xy, wrap, off = 0;
1743 int A[2], B[2], C[2];
1745 int a_valid = 0, b_valid = 0, c_valid = 0;
1746 int field_a, field_b, field_c; // 0: same, 1: opposit
1747 int total_valid, num_samefield, num_oppfield;
1748 int pos_c, pos_b, n_adj;
1750 wrap = s->b8_stride;
1751 xy = s->block_index[n];
1754 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
1755 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
1756 s->current_picture.f.motion_val[1][xy][0] = 0;
1757 s->current_picture.f.motion_val[1][xy][1] = 0;
1758 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1759 s->current_picture.f.motion_val[0][xy + 1][0] = 0;
1760 s->current_picture.f.motion_val[0][xy + 1][1] = 0;
1761 s->current_picture.f.motion_val[0][xy + wrap][0] = 0;
1762 s->current_picture.f.motion_val[0][xy + wrap][1] = 0;
1763 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
1764 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
1765 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1766 s->current_picture.f.motion_val[1][xy + 1][0] = 0;
1767 s->current_picture.f.motion_val[1][xy + 1][1] = 0;
1768 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
1769 s->current_picture.f.motion_val[1][xy + wrap][1] = 0;
1770 s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
1771 s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
1776 off = ((n == 0) || (n == 1)) ? 1 : -1;
1778 if (s->mb_x || (n == 1) || (n == 3)) {
1779 if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1780 || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1781 A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
1782 A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
1784 } else { // current block has frame mv and cand. has field MV (so average)
1785 A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
1786 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1787 A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
1788 + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1791 if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1797 /* Predict B and C */
1798 B[0] = B[1] = C[0] = C[1] = 0;
1799 if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1800 if (!s->first_slice_line) {
1801 if (!v->is_intra[s->mb_x - s->mb_stride]) {
1804 pos_b = s->block_index[n_adj] - 2 * wrap;
1805 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1806 n_adj = (n & 2) | (n & 1);
1808 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1809 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1810 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1811 B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1812 B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1815 if (s->mb_width > 1) {
1816 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1819 pos_c = s->block_index[2] - 2 * wrap + 2;
1820 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1823 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1824 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1825 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1826 C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1827 C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1829 if (s->mb_x == s->mb_width - 1) {
1830 if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1833 pos_c = s->block_index[3] - 2 * wrap - 2;
1834 if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1837 C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1838 C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1839 if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1840 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1841 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1850 pos_b = s->block_index[1];
1852 B[0] = s->current_picture.f.motion_val[0][pos_b][0];
1853 B[1] = s->current_picture.f.motion_val[0][pos_b][1];
1854 pos_c = s->block_index[0];
1856 C[0] = s->current_picture.f.motion_val[0][pos_c][0];
1857 C[1] = s->current_picture.f.motion_val[0][pos_c][1];
1860 total_valid = a_valid + b_valid + c_valid;
1861 // check if predictor A is out of bounds
1862 if (!s->mb_x && !(n == 1 || n == 3)) {
1865 // check if predictor B is out of bounds
1866 if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1867 B[0] = B[1] = C[0] = C[1] = 0;
1869 if (!v->blk_mv_type[xy]) {
1870 if (s->mb_width == 1) {
1874 if (total_valid >= 2) {
1875 px = mid_pred(A[0], B[0], C[0]);
1876 py = mid_pred(A[1], B[1], C[1]);
1877 } else if (total_valid) {
1878 if (a_valid) { px = A[0]; py = A[1]; }
1879 if (b_valid) { px = B[0]; py = B[1]; }
1880 if (c_valid) { px = C[0]; py = C[1]; }
1886 field_a = (A[1] & 4) ? 1 : 0;
1890 field_b = (B[1] & 4) ? 1 : 0;
1894 field_c = (C[1] & 4) ? 1 : 0;
1898 num_oppfield = field_a + field_b + field_c;
1899 num_samefield = total_valid - num_oppfield;
1900 if (total_valid == 3) {
1901 if ((num_samefield == 3) || (num_oppfield == 3)) {
1902 px = mid_pred(A[0], B[0], C[0]);
1903 py = mid_pred(A[1], B[1], C[1]);
1904 } else if (num_samefield >= num_oppfield) {
1905 /* take one MV from same field set depending on priority
1906 the check for B may not be necessary */
1907 px = !field_a ? A[0] : B[0];
1908 py = !field_a ? A[1] : B[1];
1910 px = field_a ? A[0] : B[0];
1911 py = field_a ? A[1] : B[1];
1913 } else if (total_valid == 2) {
1914 if (num_samefield >= num_oppfield) {
1915 if (!field_a && a_valid) {
1918 } else if (!field_b && b_valid) {
1921 } else if (c_valid) {
1926 if (field_a && a_valid) {
1929 } else if (field_b && b_valid) {
1932 } else if (c_valid) {
1937 } else if (total_valid == 1) {
1938 px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1939 py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1944 /* store MV using signed modulus of MV range defined in 4.11 */
1945 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;
1946 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;
1947 if (mvn == 1) { /* duplicate motion data for 1-MV block */
1948 s->current_picture.f.motion_val[0][xy + 1 ][0] = s->current_picture.f.motion_val[0][xy][0];
1949 s->current_picture.f.motion_val[0][xy + 1 ][1] = s->current_picture.f.motion_val[0][xy][1];
1950 s->current_picture.f.motion_val[0][xy + wrap ][0] = s->current_picture.f.motion_val[0][xy][0];
1951 s->current_picture.f.motion_val[0][xy + wrap ][1] = s->current_picture.f.motion_val[0][xy][1];
1952 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1953 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1954 } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1955 s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1956 s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1957 s->mv[0][n + 1][0] = s->mv[0][n][0];
1958 s->mv[0][n + 1][1] = s->mv[0][n][1];
1962 /** Motion compensation for direct or interpolated blocks in B-frames
1964 static void vc1_interp_mc(VC1Context *v)
1966 MpegEncContext *s = &v->s;
1967 DSPContext *dsp = &v->s.dsp;
1968 uint8_t *srcY, *srcU, *srcV;
1969 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1971 int v_edge_pos = s->v_edge_pos >> v->field_mode;
1973 if (!v->field_mode && !v->s.next_picture.f.data[0])
1976 mx = s->mv[1][0][0];
1977 my = s->mv[1][0][1];
1978 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1979 uvmy = (my + ((my & 3) == 3)) >> 1;
1980 if (v->field_mode) {
1981 if (v->cur_field_type != v->ref_field_type[1])
1982 my = my - 2 + 4 * v->cur_field_type;
1983 uvmy = uvmy - 2 + 4 * v->cur_field_type;
1986 uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1987 uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1989 srcY = s->next_picture.f.data[0];
1990 srcU = s->next_picture.f.data[1];
1991 srcV = s->next_picture.f.data[2];
1993 src_x = s->mb_x * 16 + (mx >> 2);
1994 src_y = s->mb_y * 16 + (my >> 2);
1995 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1996 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1998 if (v->profile != PROFILE_ADVANCED) {
1999 src_x = av_clip( src_x, -16, s->mb_width * 16);
2000 src_y = av_clip( src_y, -16, s->mb_height * 16);
2001 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
2002 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
2004 src_x = av_clip( src_x, -17, s->avctx->coded_width);
2005 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
2006 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
2007 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
2010 srcY += src_y * s->linesize + src_x;
2011 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
2012 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
2014 if (v->field_mode && v->ref_field_type[1]) {
2015 srcY += s->current_picture_ptr->f.linesize[0];
2016 srcU += s->current_picture_ptr->f.linesize[1];
2017 srcV += s->current_picture_ptr->f.linesize[2];
2020 /* for grayscale we should not try to read from unknown area */
2021 if (s->flags & CODEC_FLAG_GRAY) {
2022 srcU = s->edge_emu_buffer + 18 * s->linesize;
2023 srcV = s->edge_emu_buffer + 18 * s->linesize;
2027 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 16 - s->mspel * 3
2028 || (unsigned)(src_y - s->mspel) > v_edge_pos - (my & 3) - 16 - s->mspel * 3) {
2029 uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
2031 srcY -= s->mspel * (1 + s->linesize);
2032 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
2033 17 + s->mspel * 2, 17 + s->mspel * 2,
2034 src_x - s->mspel, src_y - s->mspel,
2035 s->h_edge_pos, v_edge_pos);
2036 srcY = s->edge_emu_buffer;
2037 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8 + 1, 8 + 1,
2038 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
2039 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
2040 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
2043 /* if we deal with range reduction we need to scale source blocks */
2044 if (v->rangeredfrm) {
2046 uint8_t *src, *src2;
2049 for (j = 0; j < 17 + s->mspel * 2; j++) {
2050 for (i = 0; i < 17 + s->mspel * 2; i++)
2051 src[i] = ((src[i] - 128) >> 1) + 128;
2056 for (j = 0; j < 9; j++) {
2057 for (i = 0; i < 9; i++) {
2058 src[i] = ((src[i] - 128) >> 1) + 128;
2059 src2[i] = ((src2[i] - 128) >> 1) + 128;
2061 src += s->uvlinesize;
2062 src2 += s->uvlinesize;
2065 srcY += s->mspel * (1 + s->linesize);
2068 if (v->field_mode && v->cur_field_type) {
2069 off = s->current_picture_ptr->f.linesize[0];
2070 off_uv = s->current_picture_ptr->f.linesize[1];
2077 dxy = ((my & 3) << 2) | (mx & 3);
2078 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
2079 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
2080 srcY += s->linesize * 8;
2081 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
2082 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
2084 dxy = (my & 2) | ((mx & 2) >> 1);
2087 dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
2089 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
2092 if (s->flags & CODEC_FLAG_GRAY) return;
2093 /* Chroma MC always uses qpel blilinear */
2094 uvmx = (uvmx & 3) << 1;
2095 uvmy = (uvmy & 3) << 1;
2097 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2098 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2100 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2101 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2105 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2109 #if B_FRACTION_DEN==256
2113 return 2 * ((value * n + 255) >> 9);
2114 return (value * n + 128) >> 8;
2117 n -= B_FRACTION_DEN;
2119 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2120 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2124 static av_always_inline int scale_mv_intfi(int value, int bfrac, int inv,
2125 int qs, int qs_last)
2133 return (value * n + 255) >> 9;
2135 return (value * n + 128) >> 8;
2138 /** Reconstruct motion vector for B-frame and do motion compensation
2140 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2141 int direct, int mode)
2144 v->mv_mode2 = v->mv_mode;
2145 v->mv_mode = MV_PMODE_INTENSITY_COMP;
2151 v->mv_mode = v->mv_mode2;
2154 if (mode == BMV_TYPE_INTERPOLATED) {
2158 v->mv_mode = v->mv_mode2;
2162 if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2163 v->mv_mode = v->mv_mode2;
2164 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2166 v->mv_mode = v->mv_mode2;
2169 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2170 int direct, int mvtype)
2172 MpegEncContext *s = &v->s;
2173 int xy, wrap, off = 0;
2178 const uint8_t *is_intra = v->mb_type[0];
2182 /* scale MV difference to be quad-pel */
2183 dmv_x[0] <<= 1 - s->quarter_sample;
2184 dmv_y[0] <<= 1 - s->quarter_sample;
2185 dmv_x[1] <<= 1 - s->quarter_sample;
2186 dmv_y[1] <<= 1 - s->quarter_sample;
2188 wrap = s->b8_stride;
2189 xy = s->block_index[0];
2192 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
2193 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
2194 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
2195 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
2198 if (!v->field_mode) {
2199 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2200 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2201 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2202 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2204 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2205 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));
2206 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));
2207 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));
2208 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));
2211 s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2212 s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2213 s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2214 s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2218 if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2219 C = s->current_picture.f.motion_val[0][xy - 2];
2220 A = s->current_picture.f.motion_val[0][xy - wrap * 2];
2221 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2222 B = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
2224 if (!s->mb_x) C[0] = C[1] = 0;
2225 if (!s->first_slice_line) { // predictor A is not out of bounds
2226 if (s->mb_width == 1) {
2230 px = mid_pred(A[0], B[0], C[0]);
2231 py = mid_pred(A[1], B[1], C[1]);
2233 } else if (s->mb_x) { // predictor C is not out of bounds
2239 /* Pullback MV as specified in 8.3.5.3.4 */
2242 if (v->profile < PROFILE_ADVANCED) {
2243 qx = (s->mb_x << 5);
2244 qy = (s->mb_y << 5);
2245 X = (s->mb_width << 5) - 4;
2246 Y = (s->mb_height << 5) - 4;
2247 if (qx + px < -28) px = -28 - qx;
2248 if (qy + py < -28) py = -28 - qy;
2249 if (qx + px > X) px = X - qx;
2250 if (qy + py > Y) py = Y - qy;
2252 qx = (s->mb_x << 6);
2253 qy = (s->mb_y << 6);
2254 X = (s->mb_width << 6) - 4;
2255 Y = (s->mb_height << 6) - 4;
2256 if (qx + px < -60) px = -60 - qx;
2257 if (qy + py < -60) py = -60 - qy;
2258 if (qx + px > X) px = X - qx;
2259 if (qy + py > Y) py = Y - qy;
2262 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2263 if (0 && !s->first_slice_line && s->mb_x) {
2264 if (is_intra[xy - wrap])
2265 sum = FFABS(px) + FFABS(py);
2267 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2269 if (get_bits1(&s->gb)) {
2277 if (is_intra[xy - 2])
2278 sum = FFABS(px) + FFABS(py);
2280 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2282 if (get_bits1(&s->gb)) {
2292 /* store MV using signed modulus of MV range defined in 4.11 */
2293 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2294 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2296 if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2297 C = s->current_picture.f.motion_val[1][xy - 2];
2298 A = s->current_picture.f.motion_val[1][xy - wrap * 2];
2299 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2300 B = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
2304 if (!s->first_slice_line) { // predictor A is not out of bounds
2305 if (s->mb_width == 1) {
2309 px = mid_pred(A[0], B[0], C[0]);
2310 py = mid_pred(A[1], B[1], C[1]);
2312 } else if (s->mb_x) { // predictor C is not out of bounds
2318 /* Pullback MV as specified in 8.3.5.3.4 */
2321 if (v->profile < PROFILE_ADVANCED) {
2322 qx = (s->mb_x << 5);
2323 qy = (s->mb_y << 5);
2324 X = (s->mb_width << 5) - 4;
2325 Y = (s->mb_height << 5) - 4;
2326 if (qx + px < -28) px = -28 - qx;
2327 if (qy + py < -28) py = -28 - qy;
2328 if (qx + px > X) px = X - qx;
2329 if (qy + py > Y) py = Y - qy;
2331 qx = (s->mb_x << 6);
2332 qy = (s->mb_y << 6);
2333 X = (s->mb_width << 6) - 4;
2334 Y = (s->mb_height << 6) - 4;
2335 if (qx + px < -60) px = -60 - qx;
2336 if (qy + py < -60) py = -60 - qy;
2337 if (qx + px > X) px = X - qx;
2338 if (qy + py > Y) py = Y - qy;
2341 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2342 if (0 && !s->first_slice_line && s->mb_x) {
2343 if (is_intra[xy - wrap])
2344 sum = FFABS(px) + FFABS(py);
2346 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2348 if (get_bits1(&s->gb)) {
2356 if (is_intra[xy - 2])
2357 sum = FFABS(px) + FFABS(py);
2359 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2361 if (get_bits1(&s->gb)) {
2371 /* store MV using signed modulus of MV range defined in 4.11 */
2373 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2374 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2376 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
2377 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
2378 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
2379 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
2382 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2384 int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2385 MpegEncContext *s = &v->s;
2386 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2388 if (v->bmvtype == BMV_TYPE_DIRECT) {
2389 int total_opp, k, f;
2390 if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2391 s->mv[0][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2392 v->bfraction, 0, s->quarter_sample, v->qs_last);
2393 s->mv[0][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2394 v->bfraction, 0, s->quarter_sample, v->qs_last);
2395 s->mv[1][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2396 v->bfraction, 1, s->quarter_sample, v->qs_last);
2397 s->mv[1][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2398 v->bfraction, 1, s->quarter_sample, v->qs_last);
2400 total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2401 + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2402 + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2403 + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2404 f = (total_opp > 2) ? 1 : 0;
2406 s->mv[0][0][0] = s->mv[0][0][1] = 0;
2407 s->mv[1][0][0] = s->mv[1][0][1] = 0;
2410 v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2411 for (k = 0; k < 4; k++) {
2412 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2413 s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2414 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2415 s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2416 v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2417 v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2421 if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2422 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);
2423 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);
2426 if (dir) { // backward
2427 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);
2428 if (n == 3 || mv1) {
2429 vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2432 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);
2433 if (n == 3 || mv1) {
2434 vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2439 /** Get predicted DC value for I-frames only
2440 * prediction dir: left=0, top=1
2441 * @param s MpegEncContext
2442 * @param overlap flag indicating that overlap filtering is used
2443 * @param pq integer part of picture quantizer
2444 * @param[in] n block index in the current MB
2445 * @param dc_val_ptr Pointer to DC predictor
2446 * @param dir_ptr Prediction direction for use in AC prediction
2448 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2449 int16_t **dc_val_ptr, int *dir_ptr)
2451 int a, b, c, wrap, pred, scale;
2453 static const uint16_t dcpred[32] = {
2454 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2455 114, 102, 93, 85, 79, 73, 68, 64,
2456 60, 57, 54, 51, 49, 47, 45, 43,
2457 41, 39, 38, 37, 35, 34, 33
2460 /* find prediction - wmv3_dc_scale always used here in fact */
2461 if (n < 4) scale = s->y_dc_scale;
2462 else scale = s->c_dc_scale;
2464 wrap = s->block_wrap[n];
2465 dc_val = s->dc_val[0] + s->block_index[n];
2471 b = dc_val[ - 1 - wrap];
2472 a = dc_val[ - wrap];
2474 if (pq < 9 || !overlap) {
2475 /* Set outer values */
2476 if (s->first_slice_line && (n != 2 && n != 3))
2477 b = a = dcpred[scale];
2478 if (s->mb_x == 0 && (n != 1 && n != 3))
2479 b = c = dcpred[scale];
2481 /* Set outer values */
2482 if (s->first_slice_line && (n != 2 && n != 3))
2484 if (s->mb_x == 0 && (n != 1 && n != 3))
2488 if (abs(a - b) <= abs(b - c)) {
2490 *dir_ptr = 1; // left
2493 *dir_ptr = 0; // top
2496 /* update predictor */
2497 *dc_val_ptr = &dc_val[0];
2502 /** Get predicted DC value
2503 * prediction dir: left=0, top=1
2504 * @param s MpegEncContext
2505 * @param overlap flag indicating that overlap filtering is used
2506 * @param pq integer part of picture quantizer
2507 * @param[in] n block index in the current MB
2508 * @param a_avail flag indicating top block availability
2509 * @param c_avail flag indicating left block availability
2510 * @param dc_val_ptr Pointer to DC predictor
2511 * @param dir_ptr Prediction direction for use in AC prediction
2513 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2514 int a_avail, int c_avail,
2515 int16_t **dc_val_ptr, int *dir_ptr)
2517 int a, b, c, wrap, pred;
2519 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2522 wrap = s->block_wrap[n];
2523 dc_val = s->dc_val[0] + s->block_index[n];
2529 b = dc_val[ - 1 - wrap];
2530 a = dc_val[ - wrap];
2531 /* scale predictors if needed */
2532 q1 = s->current_picture.f.qscale_table[mb_pos];
2533 if (c_avail && (n != 1 && n != 3)) {
2534 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2536 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2538 if (a_avail && (n != 2 && n != 3)) {
2539 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2541 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2543 if (a_avail && c_avail && (n != 3)) {
2548 off -= s->mb_stride;
2549 q2 = s->current_picture.f.qscale_table[off];
2551 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2554 if (a_avail && c_avail) {
2555 if (abs(a - b) <= abs(b - c)) {
2557 *dir_ptr = 1; // left
2560 *dir_ptr = 0; // top
2562 } else if (a_avail) {
2564 *dir_ptr = 0; // top
2565 } else if (c_avail) {
2567 *dir_ptr = 1; // left
2570 *dir_ptr = 1; // left
2573 /* update predictor */
2574 *dc_val_ptr = &dc_val[0];
2578 /** @} */ // Block group
2581 * @name VC1 Macroblock-level functions in Simple/Main Profiles
2582 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2586 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2587 uint8_t **coded_block_ptr)
2589 int xy, wrap, pred, a, b, c;
2591 xy = s->block_index[n];
2592 wrap = s->b8_stride;
2597 a = s->coded_block[xy - 1 ];
2598 b = s->coded_block[xy - 1 - wrap];
2599 c = s->coded_block[xy - wrap];
2608 *coded_block_ptr = &s->coded_block[xy];
2614 * Decode one AC coefficient
2615 * @param v The VC1 context
2616 * @param last Last coefficient
2617 * @param skip How much zero coefficients to skip
2618 * @param value Decoded AC coefficient value
2619 * @param codingset set of VLC to decode data
2622 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2623 int *value, int codingset)
2625 GetBitContext *gb = &v->s.gb;
2626 int index, escape, run = 0, level = 0, lst = 0;
2628 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2629 if (index != vc1_ac_sizes[codingset] - 1) {
2630 run = vc1_index_decode_table[codingset][index][0];
2631 level = vc1_index_decode_table[codingset][index][1];
2632 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2636 escape = decode210(gb);
2638 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2639 run = vc1_index_decode_table[codingset][index][0];
2640 level = vc1_index_decode_table[codingset][index][1];
2641 lst = index >= vc1_last_decode_table[codingset];
2644 level += vc1_last_delta_level_table[codingset][run];
2646 level += vc1_delta_level_table[codingset][run];
2649 run += vc1_last_delta_run_table[codingset][level] + 1;
2651 run += vc1_delta_run_table[codingset][level] + 1;
2657 lst = get_bits1(gb);
2658 if (v->s.esc3_level_length == 0) {
2659 if (v->pq < 8 || v->dquantfrm) { // table 59
2660 v->s.esc3_level_length = get_bits(gb, 3);
2661 if (!v->s.esc3_level_length)
2662 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2663 } else { // table 60
2664 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2666 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2668 run = get_bits(gb, v->s.esc3_run_length);
2669 sign = get_bits1(gb);
2670 level = get_bits(gb, v->s.esc3_level_length);
2681 /** Decode intra block in intra frames - should be faster than decode_intra_block
2682 * @param v VC1Context
2683 * @param block block to decode
2684 * @param[in] n subblock index
2685 * @param coded are AC coeffs present or not
2686 * @param codingset set of VLC to decode data
2688 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
2689 int coded, int codingset)
2691 GetBitContext *gb = &v->s.gb;
2692 MpegEncContext *s = &v->s;
2693 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2696 int16_t *ac_val, *ac_val2;
2699 /* Get DC differential */
2701 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2703 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2706 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2710 if (dcdiff == 119 /* ESC index value */) {
2711 /* TODO: Optimize */
2712 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2713 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2714 else dcdiff = get_bits(gb, 8);
2717 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2718 else if (v->pq == 2)
2719 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2726 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2729 /* Store the quantized DC coeff, used for prediction */
2731 block[0] = dcdiff * s->y_dc_scale;
2733 block[0] = dcdiff * s->c_dc_scale;
2744 int last = 0, skip, value;
2745 const uint8_t *zz_table;
2749 scale = v->pq * 2 + v->halfpq;
2753 zz_table = v->zz_8x8[2];
2755 zz_table = v->zz_8x8[3];
2757 zz_table = v->zz_8x8[1];
2759 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2761 if (dc_pred_dir) // left
2764 ac_val -= 16 * s->block_wrap[n];
2767 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2771 block[zz_table[i++]] = value;
2774 /* apply AC prediction if needed */
2776 if (dc_pred_dir) { // left
2777 for (k = 1; k < 8; k++)
2778 block[k << v->left_blk_sh] += ac_val[k];
2780 for (k = 1; k < 8; k++)
2781 block[k << v->top_blk_sh] += ac_val[k + 8];
2784 /* save AC coeffs for further prediction */
2785 for (k = 1; k < 8; k++) {
2786 ac_val2[k] = block[k << v->left_blk_sh];
2787 ac_val2[k + 8] = block[k << v->top_blk_sh];
2790 /* scale AC coeffs */
2791 for (k = 1; k < 64; k++)
2795 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2798 if (s->ac_pred) i = 63;
2804 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2808 scale = v->pq * 2 + v->halfpq;
2809 memset(ac_val2, 0, 16 * 2);
2810 if (dc_pred_dir) { // left
2813 memcpy(ac_val2, ac_val, 8 * 2);
2815 ac_val -= 16 * s->block_wrap[n];
2817 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2820 /* apply AC prediction if needed */
2822 if (dc_pred_dir) { //left
2823 for (k = 1; k < 8; k++) {
2824 block[k << v->left_blk_sh] = ac_val[k] * scale;
2825 if (!v->pquantizer && block[k << v->left_blk_sh])
2826 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2829 for (k = 1; k < 8; k++) {
2830 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2831 if (!v->pquantizer && block[k << v->top_blk_sh])
2832 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2838 s->block_last_index[n] = i;
2843 /** Decode intra block in intra frames - should be faster than decode_intra_block
2844 * @param v VC1Context
2845 * @param block block to decode
2846 * @param[in] n subblock number
2847 * @param coded are AC coeffs present or not
2848 * @param codingset set of VLC to decode data
2849 * @param mquant quantizer value for this macroblock
2851 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
2852 int coded, int codingset, int mquant)
2854 GetBitContext *gb = &v->s.gb;
2855 MpegEncContext *s = &v->s;
2856 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2859 int16_t *ac_val, *ac_val2;
2861 int a_avail = v->a_avail, c_avail = v->c_avail;
2862 int use_pred = s->ac_pred;
2865 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2867 /* Get DC differential */
2869 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2871 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2874 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2878 if (dcdiff == 119 /* ESC index value */) {
2879 /* TODO: Optimize */
2880 if (mquant == 1) dcdiff = get_bits(gb, 10);
2881 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2882 else dcdiff = get_bits(gb, 8);
2885 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2886 else if (mquant == 2)
2887 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2894 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2897 /* Store the quantized DC coeff, used for prediction */
2899 block[0] = dcdiff * s->y_dc_scale;
2901 block[0] = dcdiff * s->c_dc_scale;
2907 /* check if AC is needed at all */
2908 if (!a_avail && !c_avail)
2910 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2913 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2915 if (dc_pred_dir) // left
2918 ac_val -= 16 * s->block_wrap[n];
2920 q1 = s->current_picture.f.qscale_table[mb_pos];
2921 if ( dc_pred_dir && c_avail && mb_pos)
2922 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2923 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2924 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2925 if ( dc_pred_dir && n == 1)
2927 if (!dc_pred_dir && n == 2)
2933 int last = 0, skip, value;
2934 const uint8_t *zz_table;
2938 if (!use_pred && v->fcm == 1) {
2939 zz_table = v->zzi_8x8;
2941 if (!dc_pred_dir) // top
2942 zz_table = v->zz_8x8[2];
2944 zz_table = v->zz_8x8[3];
2948 zz_table = v->zz_8x8[1];
2950 zz_table = v->zzi_8x8;
2954 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2958 block[zz_table[i++]] = value;
2961 /* apply AC prediction if needed */
2963 /* scale predictors if needed*/
2964 if (q2 && q1 != q2) {
2965 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2966 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2968 if (dc_pred_dir) { // left
2969 for (k = 1; k < 8; k++)
2970 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2972 for (k = 1; k < 8; k++)
2973 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2976 if (dc_pred_dir) { //left
2977 for (k = 1; k < 8; k++)
2978 block[k << v->left_blk_sh] += ac_val[k];
2980 for (k = 1; k < 8; k++)
2981 block[k << v->top_blk_sh] += ac_val[k + 8];
2985 /* save AC coeffs for further prediction */
2986 for (k = 1; k < 8; k++) {
2987 ac_val2[k ] = block[k << v->left_blk_sh];
2988 ac_val2[k + 8] = block[k << v->top_blk_sh];
2991 /* scale AC coeffs */
2992 for (k = 1; k < 64; k++)
2996 block[k] += (block[k] < 0) ? -mquant : mquant;
2999 if (use_pred) i = 63;
3000 } else { // no AC coeffs
3003 memset(ac_val2, 0, 16 * 2);
3004 if (dc_pred_dir) { // left
3006 memcpy(ac_val2, ac_val, 8 * 2);
3007 if (q2 && q1 != q2) {
3008 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3009 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3010 for (k = 1; k < 8; k++)
3011 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3016 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3017 if (q2 && q1 != q2) {
3018 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3019 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3020 for (k = 1; k < 8; k++)
3021 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3026 /* apply AC prediction if needed */
3028 if (dc_pred_dir) { // left
3029 for (k = 1; k < 8; k++) {
3030 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3031 if (!v->pquantizer && block[k << v->left_blk_sh])
3032 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3035 for (k = 1; k < 8; k++) {
3036 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3037 if (!v->pquantizer && block[k << v->top_blk_sh])
3038 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3044 s->block_last_index[n] = i;
3049 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
3050 * @param v VC1Context
3051 * @param block block to decode
3052 * @param[in] n subblock index
3053 * @param coded are AC coeffs present or not
3054 * @param mquant block quantizer
3055 * @param codingset set of VLC to decode data
3057 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
3058 int coded, int mquant, int codingset)
3060 GetBitContext *gb = &v->s.gb;
3061 MpegEncContext *s = &v->s;
3062 int dc_pred_dir = 0; /* Direction of the DC prediction used */
3065 int16_t *ac_val, *ac_val2;
3067 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3068 int a_avail = v->a_avail, c_avail = v->c_avail;
3069 int use_pred = s->ac_pred;
3073 s->dsp.clear_block(block);
3075 /* XXX: Guard against dumb values of mquant */
3076 mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
3078 /* Set DC scale - y and c use the same */
3079 s->y_dc_scale = s->y_dc_scale_table[mquant];
3080 s->c_dc_scale = s->c_dc_scale_table[mquant];
3082 /* Get DC differential */
3084 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3086 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3089 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3093 if (dcdiff == 119 /* ESC index value */) {
3094 /* TODO: Optimize */
3095 if (mquant == 1) dcdiff = get_bits(gb, 10);
3096 else if (mquant == 2) dcdiff = get_bits(gb, 9);
3097 else dcdiff = get_bits(gb, 8);
3100 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
3101 else if (mquant == 2)
3102 dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
3109 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3112 /* Store the quantized DC coeff, used for prediction */
3115 block[0] = dcdiff * s->y_dc_scale;
3117 block[0] = dcdiff * s->c_dc_scale;
3123 /* check if AC is needed at all and adjust direction if needed */
3124 if (!a_avail) dc_pred_dir = 1;
3125 if (!c_avail) dc_pred_dir = 0;
3126 if (!a_avail && !c_avail) use_pred = 0;
3127 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3130 scale = mquant * 2 + v->halfpq;
3132 if (dc_pred_dir) //left
3135 ac_val -= 16 * s->block_wrap[n];
3137 q1 = s->current_picture.f.qscale_table[mb_pos];
3138 if (dc_pred_dir && c_avail && mb_pos)
3139 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
3140 if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3141 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
3142 if ( dc_pred_dir && n == 1)
3144 if (!dc_pred_dir && n == 2)
3146 if (n == 3) q2 = q1;
3149 int last = 0, skip, value;
3153 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3158 block[v->zz_8x8[0][i++]] = value;
3160 if (use_pred && (v->fcm == 1)) {
3161 if (!dc_pred_dir) // top
3162 block[v->zz_8x8[2][i++]] = value;
3164 block[v->zz_8x8[3][i++]] = value;
3166 block[v->zzi_8x8[i++]] = value;
3171 /* apply AC prediction if needed */
3173 /* scale predictors if needed*/
3174 if (q2 && q1 != q2) {
3175 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3176 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3178 if (dc_pred_dir) { // left
3179 for (k = 1; k < 8; k++)
3180 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3182 for (k = 1; k < 8; k++)
3183 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3186 if (dc_pred_dir) { // left
3187 for (k = 1; k < 8; k++)
3188 block[k << v->left_blk_sh] += ac_val[k];
3190 for (k = 1; k < 8; k++)
3191 block[k << v->top_blk_sh] += ac_val[k + 8];
3195 /* save AC coeffs for further prediction */
3196 for (k = 1; k < 8; k++) {
3197 ac_val2[k ] = block[k << v->left_blk_sh];
3198 ac_val2[k + 8] = block[k << v->top_blk_sh];
3201 /* scale AC coeffs */
3202 for (k = 1; k < 64; k++)
3206 block[k] += (block[k] < 0) ? -mquant : mquant;
3209 if (use_pred) i = 63;
3210 } else { // no AC coeffs
3213 memset(ac_val2, 0, 16 * 2);
3214 if (dc_pred_dir) { // left
3216 memcpy(ac_val2, ac_val, 8 * 2);
3217 if (q2 && q1 != q2) {
3218 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3219 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3220 for (k = 1; k < 8; k++)
3221 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3226 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3227 if (q2 && q1 != q2) {
3228 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3229 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3230 for (k = 1; k < 8; k++)
3231 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3236 /* apply AC prediction if needed */
3238 if (dc_pred_dir) { // left
3239 for (k = 1; k < 8; k++) {
3240 block[k << v->left_blk_sh] = ac_val2[k] * scale;
3241 if (!v->pquantizer && block[k << v->left_blk_sh])
3242 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3245 for (k = 1; k < 8; k++) {
3246 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3247 if (!v->pquantizer && block[k << v->top_blk_sh])
3248 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3254 s->block_last_index[n] = i;
3261 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
3262 int mquant, int ttmb, int first_block,
3263 uint8_t *dst, int linesize, int skip_block,
3266 MpegEncContext *s = &v->s;
3267 GetBitContext *gb = &s->gb;
3270 int scale, off, idx, last, skip, value;
3271 int ttblk = ttmb & 7;
3274 s->dsp.clear_block(block);
3277 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)];
3279 if (ttblk == TT_4X4) {
3280 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3282 if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3283 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3284 || (!v->res_rtm_flag && !first_block))) {
3285 subblkpat = decode012(gb);
3287 subblkpat ^= 3; // swap decoded pattern bits
3288 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3290 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3293 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3295 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3296 if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3297 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3300 if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3301 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3310 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3315 idx = v->zz_8x8[0][i++];
3317 idx = v->zzi_8x8[i++];
3318 block[idx] = value * scale;
3320 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3324 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3326 v->vc1dsp.vc1_inv_trans_8x8(block);
3327 s->dsp.add_pixels_clamped(block, dst, linesize);
3332 pat = ~subblkpat & 0xF;
3333 for (j = 0; j < 4; j++) {
3334 last = subblkpat & (1 << (3 - j));
3336 off = (j & 1) * 4 + (j & 2) * 16;
3338 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3343 idx = ff_vc1_simple_progressive_4x4_zz[i++];
3345 idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3346 block[idx + off] = value * scale;
3348 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3350 if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3352 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3354 v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3359 pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3360 for (j = 0; j < 2; j++) {
3361 last = subblkpat & (1 << (1 - j));
3365 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3370 idx = v->zz_8x4[i++] + off;
3372 idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3373 block[idx] = value * scale;
3375 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3377 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3379 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3381 v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3386 pat = ~(subblkpat * 5) & 0xF;
3387 for (j = 0; j < 2; j++) {
3388 last = subblkpat & (1 << (1 - j));
3392 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3397 idx = v->zz_4x8[i++] + off;
3399 idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3400 block[idx] = value * scale;
3402 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3404 if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3406 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3408 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3414 *ttmb_out |= ttblk << (n * 4);
3418 /** @} */ // Macroblock group
3420 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3421 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3423 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3425 MpegEncContext *s = &v->s;
3426 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3427 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3428 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3429 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3430 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3433 if (block_num > 3) {
3434 dst = s->dest[block_num - 3];
3436 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3438 if (s->mb_y != s->end_mb_y || block_num < 2) {
3442 if (block_num > 3) {
3443 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3444 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3445 mv = &v->luma_mv[s->mb_x - s->mb_stride];
3446 mv_stride = s->mb_stride;
3448 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3449 : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3450 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3451 : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3452 mv_stride = s->b8_stride;
3453 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3456 if (bottom_is_intra & 1 || block_is_intra & 1 ||
3457 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3458 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3460 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3462 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3465 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3467 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3472 dst -= 4 * linesize;
3473 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3474 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3475 idx = (block_cbp | (block_cbp >> 2)) & 3;
3477 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3480 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3482 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3487 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3489 MpegEncContext *s = &v->s;
3490 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3491 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3492 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3493 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3494 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3497 if (block_num > 3) {
3498 dst = s->dest[block_num - 3] - 8 * linesize;
3500 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3503 if (s->mb_x != s->mb_width || !(block_num & 5)) {
3506 if (block_num > 3) {
3507 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3508 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3509 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3511 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3512 : (mb_cbp >> ((block_num + 1) * 4));
3513 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3514 : (mb_is_intra >> ((block_num + 1) * 4));
3515 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3517 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3518 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3520 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3522 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3525 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3527 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3533 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3534 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3535 idx = (block_cbp | (block_cbp >> 1)) & 5;
3537 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3540 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3542 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3547 static void vc1_apply_p_loop_filter(VC1Context *v)
3549 MpegEncContext *s = &v->s;
3552 for (i = 0; i < 6; i++) {
3553 vc1_apply_p_v_loop_filter(v, i);
3556 /* V always preceedes H, therefore we run H one MB before V;
3557 * at the end of a row, we catch up to complete the row */
3559 for (i = 0; i < 6; i++) {
3560 vc1_apply_p_h_loop_filter(v, i);
3562 if (s->mb_x == s->mb_width - 1) {
3564 ff_update_block_index(s);
3565 for (i = 0; i < 6; i++) {
3566 vc1_apply_p_h_loop_filter(v, i);
3572 /** Decode one P-frame MB
3574 static int vc1_decode_p_mb(VC1Context *v)
3576 MpegEncContext *s = &v->s;
3577 GetBitContext *gb = &s->gb;
3579 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3580 int cbp; /* cbp decoding stuff */
3581 int mqdiff, mquant; /* MB quantization */
3582 int ttmb = v->ttfrm; /* MB Transform type */
3584 int mb_has_coeffs = 1; /* last_flag */
3585 int dmv_x, dmv_y; /* Differential MV components */
3586 int index, index1; /* LUT indexes */
3587 int val, sign; /* temp values */
3588 int first_block = 1;
3590 int skipped, fourmv;
3591 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3593 mquant = v->pq; /* Loosy initialization */
3595 if (v->mv_type_is_raw)
3596 fourmv = get_bits1(gb);
3598 fourmv = v->mv_type_mb_plane[mb_pos];
3600 skipped = get_bits1(gb);
3602 skipped = v->s.mbskip_table[mb_pos];
3604 if (!fourmv) { /* 1MV mode */
3606 GET_MVDATA(dmv_x, dmv_y);
3609 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3610 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3612 s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3613 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3615 /* FIXME Set DC val for inter block ? */
3616 if (s->mb_intra && !mb_has_coeffs) {
3618 s->ac_pred = get_bits1(gb);
3620 } else if (mb_has_coeffs) {
3622 s->ac_pred = get_bits1(gb);
3623 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3629 s->current_picture.f.qscale_table[mb_pos] = mquant;
3631 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3632 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3633 VC1_TTMB_VLC_BITS, 2);
3634 if (!s->mb_intra) vc1_mc_1mv(v, 0);
3636 for (i = 0; i < 6; i++) {
3637 s->dc_val[0][s->block_index[i]] = 0;
3639 val = ((cbp >> (5 - i)) & 1);
3640 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3641 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3643 /* check if prediction blocks A and C are available */
3644 v->a_avail = v->c_avail = 0;
3645 if (i == 2 || i == 3 || !s->first_slice_line)
3646 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3647 if (i == 1 || i == 3 || s->mb_x)
3648 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3650 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3651 (i & 4) ? v->codingset2 : v->codingset);
3652 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3654 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3656 for (j = 0; j < 64; j++)
3657 s->block[i][j] <<= 1;
3658 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3659 if (v->pq >= 9 && v->overlap) {
3661 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3663 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3665 block_cbp |= 0xF << (i << 2);
3666 block_intra |= 1 << i;
3668 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3669 s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3670 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3671 block_cbp |= pat << (i << 2);
3672 if (!v->ttmbf && ttmb < 8)
3679 for (i = 0; i < 6; i++) {
3680 v->mb_type[0][s->block_index[i]] = 0;
3681 s->dc_val[0][s->block_index[i]] = 0;
3683 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
3684 s->current_picture.f.qscale_table[mb_pos] = 0;
3685 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3688 } else { // 4MV mode
3689 if (!skipped /* unskipped MB */) {
3690 int intra_count = 0, coded_inter = 0;
3691 int is_intra[6], is_coded[6];
3693 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3694 for (i = 0; i < 6; i++) {
3695 val = ((cbp >> (5 - i)) & 1);
3696 s->dc_val[0][s->block_index[i]] = 0;
3703 GET_MVDATA(dmv_x, dmv_y);
3705 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3707 vc1_mc_4mv_luma(v, i, 0);
3708 intra_count += s->mb_intra;
3709 is_intra[i] = s->mb_intra;
3710 is_coded[i] = mb_has_coeffs;
3713 is_intra[i] = (intra_count >= 3);
3717 vc1_mc_4mv_chroma(v, 0);
3718 v->mb_type[0][s->block_index[i]] = is_intra[i];
3720 coded_inter = !is_intra[i] & is_coded[i];
3722 // if there are no coded blocks then don't do anything more
3724 if (!intra_count && !coded_inter)
3727 s->current_picture.f.qscale_table[mb_pos] = mquant;
3728 /* test if block is intra and has pred */
3731 for (i = 0; i < 6; i++)
3733 if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3734 || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3740 s->ac_pred = get_bits1(gb);
3744 if (!v->ttmbf && coded_inter)
3745 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3746 for (i = 0; i < 6; i++) {
3748 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3749 s->mb_intra = is_intra[i];
3751 /* check if prediction blocks A and C are available */
3752 v->a_avail = v->c_avail = 0;
3753 if (i == 2 || i == 3 || !s->first_slice_line)
3754 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3755 if (i == 1 || i == 3 || s->mb_x)
3756 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3758 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3759 (i & 4) ? v->codingset2 : v->codingset);
3760 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3762 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3764 for (j = 0; j < 64; j++)
3765 s->block[i][j] <<= 1;
3766 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3767 (i & 4) ? s->uvlinesize : s->linesize);
3768 if (v->pq >= 9 && v->overlap) {
3770 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3772 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3774 block_cbp |= 0xF << (i << 2);
3775 block_intra |= 1 << i;
3776 } else if (is_coded[i]) {
3777 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3778 first_block, s->dest[dst_idx] + off,
3779 (i & 4) ? s->uvlinesize : s->linesize,
3780 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3782 block_cbp |= pat << (i << 2);
3783 if (!v->ttmbf && ttmb < 8)
3788 } else { // skipped MB
3790 s->current_picture.f.qscale_table[mb_pos] = 0;
3791 for (i = 0; i < 6; i++) {
3792 v->mb_type[0][s->block_index[i]] = 0;
3793 s->dc_val[0][s->block_index[i]] = 0;
3795 for (i = 0; i < 4; i++) {
3796 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3797 vc1_mc_4mv_luma(v, i, 0);
3799 vc1_mc_4mv_chroma(v, 0);
3800 s->current_picture.f.qscale_table[mb_pos] = 0;
3804 v->cbp[s->mb_x] = block_cbp;
3805 v->ttblk[s->mb_x] = block_tt;
3806 v->is_intra[s->mb_x] = block_intra;
3811 /* Decode one macroblock in an interlaced frame p picture */
3813 static int vc1_decode_p_mb_intfr(VC1Context *v)
3815 MpegEncContext *s = &v->s;
3816 GetBitContext *gb = &s->gb;
3818 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3819 int cbp = 0; /* cbp decoding stuff */
3820 int mqdiff, mquant; /* MB quantization */
3821 int ttmb = v->ttfrm; /* MB Transform type */
3823 int mb_has_coeffs = 1; /* last_flag */
3824 int dmv_x, dmv_y; /* Differential MV components */
3825 int val; /* temp value */
3826 int first_block = 1;
3828 int skipped, fourmv = 0, twomv = 0;
3829 int block_cbp = 0, pat, block_tt = 0;
3830 int idx_mbmode = 0, mvbp;
3831 int stride_y, fieldtx;
3833 mquant = v->pq; /* Loosy initialization */
3836 skipped = get_bits1(gb);
3838 skipped = v->s.mbskip_table[mb_pos];
3840 if (v->fourmvswitch)
3841 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3843 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3844 switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3845 /* store the motion vector type in a flag (useful later) */
3846 case MV_PMODE_INTFR_4MV:
3848 v->blk_mv_type[s->block_index[0]] = 0;
3849 v->blk_mv_type[s->block_index[1]] = 0;
3850 v->blk_mv_type[s->block_index[2]] = 0;
3851 v->blk_mv_type[s->block_index[3]] = 0;
3853 case MV_PMODE_INTFR_4MV_FIELD:
3855 v->blk_mv_type[s->block_index[0]] = 1;
3856 v->blk_mv_type[s->block_index[1]] = 1;
3857 v->blk_mv_type[s->block_index[2]] = 1;
3858 v->blk_mv_type[s->block_index[3]] = 1;
3860 case MV_PMODE_INTFR_2MV_FIELD:
3862 v->blk_mv_type[s->block_index[0]] = 1;
3863 v->blk_mv_type[s->block_index[1]] = 1;
3864 v->blk_mv_type[s->block_index[2]] = 1;
3865 v->blk_mv_type[s->block_index[3]] = 1;
3867 case MV_PMODE_INTFR_1MV:
3868 v->blk_mv_type[s->block_index[0]] = 0;
3869 v->blk_mv_type[s->block_index[1]] = 0;
3870 v->blk_mv_type[s->block_index[2]] = 0;
3871 v->blk_mv_type[s->block_index[3]] = 0;
3874 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3875 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3876 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3877 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
3878 s->mb_intra = v->is_intra[s->mb_x] = 1;
3879 for (i = 0; i < 6; i++)
3880 v->mb_type[0][s->block_index[i]] = 1;
3881 fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3882 mb_has_coeffs = get_bits1(gb);
3884 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3885 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3887 s->current_picture.f.qscale_table[mb_pos] = mquant;
3888 /* Set DC scale - y and c use the same (not sure if necessary here) */
3889 s->y_dc_scale = s->y_dc_scale_table[mquant];
3890 s->c_dc_scale = s->c_dc_scale_table[mquant];
3892 for (i = 0; i < 6; i++) {
3893 s->dc_val[0][s->block_index[i]] = 0;
3895 val = ((cbp >> (5 - i)) & 1);
3896 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3897 v->a_avail = v->c_avail = 0;
3898 if (i == 2 || i == 3 || !s->first_slice_line)
3899 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3900 if (i == 1 || i == 3 || s->mb_x)
3901 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3903 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3904 (i & 4) ? v->codingset2 : v->codingset);
3905 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3906 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3908 stride_y = s->linesize << fieldtx;
3909 off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3911 stride_y = s->uvlinesize;
3914 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3918 } else { // inter MB
3919 mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3921 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3922 if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3923 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3925 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3926 || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3927 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3930 s->mb_intra = v->is_intra[s->mb_x] = 0;
3931 for (i = 0; i < 6; i++)
3932 v->mb_type[0][s->block_index[i]] = 0;
3933 fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3934 /* for all motion vector read MVDATA and motion compensate each block */
3938 for (i = 0; i < 6; i++) {
3941 val = ((mvbp >> (3 - i)) & 1);
3943 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3945 vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3946 vc1_mc_4mv_luma(v, i, 0);
3947 } else if (i == 4) {
3948 vc1_mc_4mv_chroma4(v);
3955 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3957 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3958 vc1_mc_4mv_luma(v, 0, 0);
3959 vc1_mc_4mv_luma(v, 1, 0);
3962 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3964 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3965 vc1_mc_4mv_luma(v, 2, 0);
3966 vc1_mc_4mv_luma(v, 3, 0);
3967 vc1_mc_4mv_chroma4(v);
3969 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3971 get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3973 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3977 GET_MQUANT(); // p. 227
3978 s->current_picture.f.qscale_table[mb_pos] = mquant;
3979 if (!v->ttmbf && cbp)
3980 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3981 for (i = 0; i < 6; i++) {
3982 s->dc_val[0][s->block_index[i]] = 0;
3984 val = ((cbp >> (5 - i)) & 1);
3986 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3988 off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3990 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3991 first_block, s->dest[dst_idx] + off,
3992 (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3993 (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3994 block_cbp |= pat << (i << 2);
3995 if (!v->ttmbf && ttmb < 8)
4002 s->mb_intra = v->is_intra[s->mb_x] = 0;
4003 for (i = 0; i < 6; i++) {
4004 v->mb_type[0][s->block_index[i]] = 0;
4005 s->dc_val[0][s->block_index[i]] = 0;
4007 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
4008 s->current_picture.f.qscale_table[mb_pos] = 0;
4009 v->blk_mv_type[s->block_index[0]] = 0;
4010 v->blk_mv_type[s->block_index[1]] = 0;
4011 v->blk_mv_type[s->block_index[2]] = 0;
4012 v->blk_mv_type[s->block_index[3]] = 0;
4013 vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
4016 if (s->mb_x == s->mb_width - 1)
4017 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
4021 static int vc1_decode_p_mb_intfi(VC1Context *v)
4023 MpegEncContext *s = &v->s;
4024 GetBitContext *gb = &s->gb;
4026 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4027 int cbp = 0; /* cbp decoding stuff */
4028 int mqdiff, mquant; /* MB quantization */
4029 int ttmb = v->ttfrm; /* MB Transform type */
4031 int mb_has_coeffs = 1; /* last_flag */
4032 int dmv_x, dmv_y; /* Differential MV components */
4033 int val; /* temp values */
4034 int first_block = 1;
4037 int block_cbp = 0, pat, block_tt = 0;
4040 mquant = v->pq; /* Loosy initialization */
4042 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4043 if (idx_mbmode <= 1) { // intra MB
4044 s->mb_intra = v->is_intra[s->mb_x] = 1;
4045 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4046 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4047 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4049 s->current_picture.f.qscale_table[mb_pos] = mquant;
4050 /* Set DC scale - y and c use the same (not sure if necessary here) */
4051 s->y_dc_scale = s->y_dc_scale_table[mquant];
4052 s->c_dc_scale = s->c_dc_scale_table[mquant];
4053 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4054 mb_has_coeffs = idx_mbmode & 1;
4056 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4058 for (i = 0; i < 6; i++) {
4059 s->dc_val[0][s->block_index[i]] = 0;
4060 v->mb_type[0][s->block_index[i]] = 1;
4062 val = ((cbp >> (5 - i)) & 1);
4063 v->a_avail = v->c_avail = 0;
4064 if (i == 2 || i == 3 || !s->first_slice_line)
4065 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4066 if (i == 1 || i == 3 || s->mb_x)
4067 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4069 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4070 (i & 4) ? v->codingset2 : v->codingset);
4071 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4073 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4074 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4075 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4076 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4077 // TODO: loop filter
4080 s->mb_intra = v->is_intra[s->mb_x] = 0;
4081 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4082 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4083 if (idx_mbmode <= 5) { // 1-MV
4085 if (idx_mbmode & 1) {
4086 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4088 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4090 mb_has_coeffs = !(idx_mbmode & 2);
4092 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4093 for (i = 0; i < 6; i++) {
4095 dmv_x = dmv_y = pred_flag = 0;
4096 val = ((v->fourmvbp >> (3 - i)) & 1);
4098 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4100 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4101 vc1_mc_4mv_luma(v, i, 0);
4103 vc1_mc_4mv_chroma(v, 0);
4105 mb_has_coeffs = idx_mbmode & 1;
4108 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4112 s->current_picture.f.qscale_table[mb_pos] = mquant;
4113 if (!v->ttmbf && cbp) {
4114 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4117 for (i = 0; i < 6; i++) {
4118 s->dc_val[0][s->block_index[i]] = 0;
4120 val = ((cbp >> (5 - i)) & 1);
4121 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4122 if (v->cur_field_type)
4123 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4125 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4126 first_block, s->dest[dst_idx] + off,
4127 (i & 4) ? s->uvlinesize : s->linesize,
4128 (i & 4) && (s->flags & CODEC_FLAG_GRAY),
4130 block_cbp |= pat << (i << 2);
4131 if (!v->ttmbf && ttmb < 8) ttmb = -1;
4136 if (s->mb_x == s->mb_width - 1)
4137 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4141 /** Decode one B-frame MB (in Main profile)
4143 static void vc1_decode_b_mb(VC1Context *v)
4145 MpegEncContext *s = &v->s;
4146 GetBitContext *gb = &s->gb;
4148 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4149 int cbp = 0; /* cbp decoding stuff */
4150 int mqdiff, mquant; /* MB quantization */
4151 int ttmb = v->ttfrm; /* MB Transform type */
4152 int mb_has_coeffs = 0; /* last_flag */
4153 int index, index1; /* LUT indexes */
4154 int val, sign; /* temp values */
4155 int first_block = 1;
4157 int skipped, direct;
4158 int dmv_x[2], dmv_y[2];
4159 int bmvtype = BMV_TYPE_BACKWARD;
4161 mquant = v->pq; /* Loosy initialization */
4165 direct = get_bits1(gb);
4167 direct = v->direct_mb_plane[mb_pos];
4169 skipped = get_bits1(gb);
4171 skipped = v->s.mbskip_table[mb_pos];
4173 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4174 for (i = 0; i < 6; i++) {
4175 v->mb_type[0][s->block_index[i]] = 0;
4176 s->dc_val[0][s->block_index[i]] = 0;
4178 s->current_picture.f.qscale_table[mb_pos] = 0;
4182 GET_MVDATA(dmv_x[0], dmv_y[0]);
4183 dmv_x[1] = dmv_x[0];
4184 dmv_y[1] = dmv_y[0];
4186 if (skipped || !s->mb_intra) {
4187 bmvtype = decode012(gb);
4190 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4193 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4196 bmvtype = BMV_TYPE_INTERPOLATED;
4197 dmv_x[0] = dmv_y[0] = 0;
4201 for (i = 0; i < 6; i++)
4202 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4206 bmvtype = BMV_TYPE_INTERPOLATED;
4207 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4208 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4212 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4215 s->current_picture.f.qscale_table[mb_pos] = mquant;
4217 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4218 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4219 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4220 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4222 if (!mb_has_coeffs && !s->mb_intra) {
4223 /* no coded blocks - effectively skipped */
4224 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4225 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4228 if (s->mb_intra && !mb_has_coeffs) {
4230 s->current_picture.f.qscale_table[mb_pos] = mquant;
4231 s->ac_pred = get_bits1(gb);
4233 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4235 if (bmvtype == BMV_TYPE_INTERPOLATED) {
4236 GET_MVDATA(dmv_x[0], dmv_y[0]);
4237 if (!mb_has_coeffs) {
4238 /* interpolated skipped block */
4239 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4240 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4244 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4246 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4249 s->ac_pred = get_bits1(gb);
4250 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4252 s->current_picture.f.qscale_table[mb_pos] = mquant;
4253 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4254 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4258 for (i = 0; i < 6; i++) {
4259 s->dc_val[0][s->block_index[i]] = 0;
4261 val = ((cbp >> (5 - i)) & 1);
4262 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4263 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4265 /* check if prediction blocks A and C are available */
4266 v->a_avail = v->c_avail = 0;
4267 if (i == 2 || i == 3 || !s->first_slice_line)
4268 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4269 if (i == 1 || i == 3 || s->mb_x)
4270 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4272 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4273 (i & 4) ? v->codingset2 : v->codingset);
4274 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4276 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4278 for (j = 0; j < 64; j++)
4279 s->block[i][j] <<= 1;
4280 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4282 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4283 first_block, s->dest[dst_idx] + off,
4284 (i & 4) ? s->uvlinesize : s->linesize,
4285 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4286 if (!v->ttmbf && ttmb < 8)
4293 /** Decode one B-frame MB (in interlaced field B picture)
4295 static void vc1_decode_b_mb_intfi(VC1Context *v)
4297 MpegEncContext *s = &v->s;
4298 GetBitContext *gb = &s->gb;
4300 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4301 int cbp = 0; /* cbp decoding stuff */
4302 int mqdiff, mquant; /* MB quantization */
4303 int ttmb = v->ttfrm; /* MB Transform type */
4304 int mb_has_coeffs = 0; /* last_flag */
4305 int val; /* temp value */
4306 int first_block = 1;
4309 int dmv_x[2], dmv_y[2], pred_flag[2];
4310 int bmvtype = BMV_TYPE_BACKWARD;
4311 int idx_mbmode, interpmvp;
4313 mquant = v->pq; /* Loosy initialization */
4316 idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4317 if (idx_mbmode <= 1) { // intra MB
4318 s->mb_intra = v->is_intra[s->mb_x] = 1;
4319 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4320 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4321 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4323 s->current_picture.f.qscale_table[mb_pos] = mquant;
4324 /* Set DC scale - y and c use the same (not sure if necessary here) */
4325 s->y_dc_scale = s->y_dc_scale_table[mquant];
4326 s->c_dc_scale = s->c_dc_scale_table[mquant];
4327 v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4328 mb_has_coeffs = idx_mbmode & 1;
4330 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4332 for (i = 0; i < 6; i++) {
4333 s->dc_val[0][s->block_index[i]] = 0;
4335 val = ((cbp >> (5 - i)) & 1);
4336 v->mb_type[0][s->block_index[i]] = s->mb_intra;
4337 v->a_avail = v->c_avail = 0;
4338 if (i == 2 || i == 3 || !s->first_slice_line)
4339 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4340 if (i == 1 || i == 3 || s->mb_x)
4341 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4343 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4344 (i & 4) ? v->codingset2 : v->codingset);
4345 if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4347 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4349 for (j = 0; j < 64; j++)
4350 s->block[i][j] <<= 1;
4351 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4352 off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4353 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4354 // TODO: yet to perform loop filter
4357 s->mb_intra = v->is_intra[s->mb_x] = 0;
4358 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4359 for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4361 fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4363 fwd = v->forward_mb_plane[mb_pos];
4364 if (idx_mbmode <= 5) { // 1-MV
4365 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4366 pred_flag[0] = pred_flag[1] = 0;
4368 bmvtype = BMV_TYPE_FORWARD;
4370 bmvtype = decode012(gb);
4373 bmvtype = BMV_TYPE_BACKWARD;
4376 bmvtype = BMV_TYPE_DIRECT;
4379 bmvtype = BMV_TYPE_INTERPOLATED;
4380 interpmvp = get_bits1(gb);
4383 v->bmvtype = bmvtype;
4384 if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4385 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4387 if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4388 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4390 if (bmvtype == BMV_TYPE_DIRECT) {
4391 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4392 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4394 vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4395 vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4396 mb_has_coeffs = !(idx_mbmode & 2);
4399 bmvtype = BMV_TYPE_FORWARD;
4400 v->bmvtype = bmvtype;
4401 v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4402 for (i = 0; i < 6; i++) {
4404 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4405 dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4406 val = ((v->fourmvbp >> (3 - i)) & 1);
4408 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4409 &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4410 &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4412 vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4413 vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4415 vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4417 mb_has_coeffs = idx_mbmode & 1;
4420 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4424 s->current_picture.f.qscale_table[mb_pos] = mquant;
4425 if (!v->ttmbf && cbp) {
4426 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4429 for (i = 0; i < 6; i++) {
4430 s->dc_val[0][s->block_index[i]] = 0;
4432 val = ((cbp >> (5 - i)) & 1);
4433 off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4434 if (v->cur_field_type)
4435 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4437 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4438 first_block, s->dest[dst_idx] + off,
4439 (i & 4) ? s->uvlinesize : s->linesize,
4440 (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4441 if (!v->ttmbf && ttmb < 8)
4449 /** Decode blocks of I-frame
4451 static void vc1_decode_i_blocks(VC1Context *v)
4454 MpegEncContext *s = &v->s;
4459 /* select codingmode used for VLC tables selection */
4460 switch (v->y_ac_table_index) {
4462 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4465 v->codingset = CS_HIGH_MOT_INTRA;
4468 v->codingset = CS_MID_RATE_INTRA;
4472 switch (v->c_ac_table_index) {
4474 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4477 v->codingset2 = CS_HIGH_MOT_INTER;
4480 v->codingset2 = CS_MID_RATE_INTER;
4484 /* Set DC scale - y and c use the same */
4485 s->y_dc_scale = s->y_dc_scale_table[v->pq];
4486 s->c_dc_scale = s->c_dc_scale_table[v->pq];
4489 s->mb_x = s->mb_y = 0;
4491 s->first_slice_line = 1;
4492 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4494 ff_init_block_index(s);
4495 for (; s->mb_x < s->mb_width; s->mb_x++) {
4497 ff_update_block_index(s);
4498 dst[0] = s->dest[0];
4499 dst[1] = dst[0] + 8;
4500 dst[2] = s->dest[0] + s->linesize * 8;
4501 dst[3] = dst[2] + 8;
4502 dst[4] = s->dest[1];
4503 dst[5] = s->dest[2];
4504 s->dsp.clear_blocks(s->block[0]);
4505 mb_pos = s->mb_x + s->mb_y * s->mb_width;
4506 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
4507 s->current_picture.f.qscale_table[mb_pos] = v->pq;
4508 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4509 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4511 // do actual MB decoding and displaying
4512 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4513 v->s.ac_pred = get_bits1(&v->s.gb);
4515 for (k = 0; k < 6; k++) {
4516 val = ((cbp >> (5 - k)) & 1);
4519 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4523 cbp |= val << (5 - k);
4525 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4527 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4529 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4530 if (v->pq >= 9 && v->overlap) {
4532 for (j = 0; j < 64; j++)
4533 s->block[k][j] <<= 1;
4534 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4537 for (j = 0; j < 64; j++)
4538 s->block[k][j] = (s->block[k][j] - 64) << 1;
4539 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4543 if (v->pq >= 9 && v->overlap) {
4545 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4546 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4547 if (!(s->flags & CODEC_FLAG_GRAY)) {
4548 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4549 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4552 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4553 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4554 if (!s->first_slice_line) {
4555 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4556 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4557 if (!(s->flags & CODEC_FLAG_GRAY)) {
4558 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4559 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4562 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4563 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4565 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4567 if (get_bits_count(&s->gb) > v->bits) {
4568 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
4569 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4570 get_bits_count(&s->gb), v->bits);
4574 if (!v->s.loop_filter)
4575 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4577 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4579 s->first_slice_line = 0;
4581 if (v->s.loop_filter)
4582 ff_draw_horiz_band(s, (s->mb_height - 1) * 16, 16);
4583 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4586 /** Decode blocks of I-frame for advanced profile
4588 static void vc1_decode_i_blocks_adv(VC1Context *v)
4591 MpegEncContext *s = &v->s;
4597 GetBitContext *gb = &s->gb;
4599 /* select codingmode used for VLC tables selection */
4600 switch (v->y_ac_table_index) {
4602 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4605 v->codingset = CS_HIGH_MOT_INTRA;
4608 v->codingset = CS_MID_RATE_INTRA;
4612 switch (v->c_ac_table_index) {
4614 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4617 v->codingset2 = CS_HIGH_MOT_INTER;
4620 v->codingset2 = CS_MID_RATE_INTER;
4625 s->mb_x = s->mb_y = 0;
4627 s->first_slice_line = 1;
4628 s->mb_y = s->start_mb_y;
4629 if (s->start_mb_y) {
4631 ff_init_block_index(s);
4632 memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4633 (1 + s->b8_stride) * sizeof(*s->coded_block));
4635 for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4637 ff_init_block_index(s);
4638 for (;s->mb_x < s->mb_width; s->mb_x++) {
4639 DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
4640 ff_update_block_index(s);
4641 s->dsp.clear_blocks(block[0]);
4642 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4643 s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4644 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4645 s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4647 // do actual MB decoding and displaying
4648 if (v->fieldtx_is_raw)
4649 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4650 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4651 if ( v->acpred_is_raw)
4652 v->s.ac_pred = get_bits1(&v->s.gb);
4654 v->s.ac_pred = v->acpred_plane[mb_pos];
4656 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4657 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4661 s->current_picture.f.qscale_table[mb_pos] = mquant;
4662 /* Set DC scale - y and c use the same */
4663 s->y_dc_scale = s->y_dc_scale_table[mquant];
4664 s->c_dc_scale = s->c_dc_scale_table[mquant];
4666 for (k = 0; k < 6; k++) {
4667 val = ((cbp >> (5 - k)) & 1);
4670 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4674 cbp |= val << (5 - k);
4676 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4677 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4679 vc1_decode_i_block_adv(v, block[k], k, val,
4680 (k < 4) ? v->codingset : v->codingset2, mquant);
4682 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4684 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4687 vc1_smooth_overlap_filter_iblk(v);
4688 vc1_put_signed_blocks_clamped(v);
4689 if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4691 if (get_bits_count(&s->gb) > v->bits) {
4692 // TODO: may need modification to handle slice coding
4693 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
4694 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4695 get_bits_count(&s->gb), v->bits);
4699 if (!v->s.loop_filter)
4700 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4702 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4703 s->first_slice_line = 0;
4706 /* raw bottom MB row */
4708 ff_init_block_index(s);
4709 for (;s->mb_x < s->mb_width; s->mb_x++) {
4710 ff_update_block_index(s);
4711 vc1_put_signed_blocks_clamped(v);
4712 if (v->s.loop_filter)
4713 vc1_loop_filter_iblk_delayed(v, v->pq);
4715 if (v->s.loop_filter)
4716 ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4717 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4718 (s->end_mb_y << v->field_mode) - 1, (AC_END|DC_END|MV_END));
4721 static void vc1_decode_p_blocks(VC1Context *v)
4723 MpegEncContext *s = &v->s;
4724 int apply_loop_filter;
4726 /* select codingmode used for VLC tables selection */
4727 switch (v->c_ac_table_index) {
4729 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4732 v->codingset = CS_HIGH_MOT_INTRA;
4735 v->codingset = CS_MID_RATE_INTRA;
4739 switch (v->c_ac_table_index) {
4741 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4744 v->codingset2 = CS_HIGH_MOT_INTER;
4747 v->codingset2 = CS_MID_RATE_INTER;
4751 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
4752 s->first_slice_line = 1;
4753 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
4754 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4756 ff_init_block_index(s);
4757 for (; s->mb_x < s->mb_width; s->mb_x++) {
4758 ff_update_block_index(s);
4761 vc1_decode_p_mb_intfi(v);
4762 else if (v->fcm == 1)
4763 vc1_decode_p_mb_intfr(v);
4764 else vc1_decode_p_mb(v);
4765 if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == 0)
4766 vc1_apply_p_loop_filter(v);
4767 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4768 // TODO: may need modification to handle slice coding
4769 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
4770 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4771 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4775 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
4776 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
4777 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4778 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
4779 if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4780 s->first_slice_line = 0;
4782 if (apply_loop_filter) {
4784 ff_init_block_index(s);
4785 for (; s->mb_x < s->mb_width; s->mb_x++) {
4786 ff_update_block_index(s);
4787 vc1_apply_p_loop_filter(v);
4790 if (s->end_mb_y >= s->start_mb_y)
4791 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4792 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4793 (s->end_mb_y << v->field_mode) - 1, (AC_END|DC_END|MV_END));
4796 static void vc1_decode_b_blocks(VC1Context *v)
4798 MpegEncContext *s = &v->s;
4800 /* select codingmode used for VLC tables selection */
4801 switch (v->c_ac_table_index) {
4803 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4806 v->codingset = CS_HIGH_MOT_INTRA;
4809 v->codingset = CS_MID_RATE_INTRA;
4813 switch (v->c_ac_table_index) {
4815 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4818 v->codingset2 = CS_HIGH_MOT_INTER;
4821 v->codingset2 = CS_MID_RATE_INTER;
4825 s->first_slice_line = 1;
4826 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4828 ff_init_block_index(s);
4829 for (; s->mb_x < s->mb_width; s->mb_x++) {
4830 ff_update_block_index(s);
4833 vc1_decode_b_mb_intfi(v);
4836 if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4837 // TODO: may need modification to handle slice coding
4838 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
4839 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4840 get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4843 if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4845 if (!v->s.loop_filter)
4846 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4848 ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4849 s->first_slice_line = 0;
4851 if (v->s.loop_filter)
4852 ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4853 ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4854 (s->end_mb_y << v->field_mode) - 1, (AC_END|DC_END|MV_END));
4857 static void vc1_decode_skip_blocks(VC1Context *v)
4859 MpegEncContext *s = &v->s;
4861 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, (AC_END|DC_END|MV_END));
4862 s->first_slice_line = 1;
4863 for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4865 ff_init_block_index(s);
4866 ff_update_block_index(s);
4867 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4868 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4869 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4870 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4871 s->first_slice_line = 0;
4873 s->pict_type = AV_PICTURE_TYPE_P;
4876 static void vc1_decode_blocks(VC1Context *v)
4879 v->s.esc3_level_length = 0;
4881 ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
4884 v->left_blk_idx = -1;
4885 v->topleft_blk_idx = 1;
4887 switch (v->s.pict_type) {
4888 case AV_PICTURE_TYPE_I:
4889 if (v->profile == PROFILE_ADVANCED)
4890 vc1_decode_i_blocks_adv(v);
4892 vc1_decode_i_blocks(v);
4894 case AV_PICTURE_TYPE_P:
4895 if (v->p_frame_skipped)
4896 vc1_decode_skip_blocks(v);
4898 vc1_decode_p_blocks(v);
4900 case AV_PICTURE_TYPE_B:
4902 if (v->profile == PROFILE_ADVANCED)
4903 vc1_decode_i_blocks_adv(v);
4905 vc1_decode_i_blocks(v);
4907 vc1_decode_b_blocks(v);
4913 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
4917 * Transform coefficients for both sprites in 16.16 fixed point format,
4918 * in the order they appear in the bitstream:
4920 * rotation 1 (unused)
4922 * rotation 2 (unused)
4929 int effect_type, effect_flag;
4930 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
4931 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
4934 static inline int get_fp_val(GetBitContext* gb)
4936 return (get_bits_long(gb, 30) - (1 << 29)) << 1;
4939 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
4943 switch (get_bits(gb, 2)) {
4946 c[2] = get_fp_val(gb);
4950 c[0] = c[4] = get_fp_val(gb);
4951 c[2] = get_fp_val(gb);
4954 c[0] = get_fp_val(gb);
4955 c[2] = get_fp_val(gb);
4956 c[4] = get_fp_val(gb);
4959 c[0] = get_fp_val(gb);
4960 c[1] = get_fp_val(gb);
4961 c[2] = get_fp_val(gb);
4962 c[3] = get_fp_val(gb);
4963 c[4] = get_fp_val(gb);
4966 c[5] = get_fp_val(gb);
4968 c[6] = get_fp_val(gb);
4973 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
4975 AVCodecContext *avctx = v->s.avctx;
4978 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4979 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
4980 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
4981 av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
4982 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
4983 for (i = 0; i < 7; i++)
4984 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
4985 sd->coefs[sprite][i] / (1<<16),
4986 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
4987 av_log(avctx, AV_LOG_DEBUG, "\n");
4991 if (sd->effect_type = get_bits_long(gb, 30)) {
4992 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
4994 vc1_sprite_parse_transform(gb, sd->effect_params1);
4997 vc1_sprite_parse_transform(gb, sd->effect_params1);
4998 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
5001 for (i = 0; i < sd->effect_pcount1; i++)
5002 sd->effect_params1[i] = get_fp_val(gb);
5004 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
5005 // effect 13 is simple alpha blending and matches the opacity above
5006 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
5007 for (i = 0; i < sd->effect_pcount1; i++)
5008 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5009 sd->effect_params1[i] / (1 << 16),
5010 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
5011 av_log(avctx, AV_LOG_DEBUG, "\n");
5014 sd->effect_pcount2 = get_bits(gb, 16);
5015 if (sd->effect_pcount2 > 10) {
5016 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
5018 } else if (sd->effect_pcount2) {
5020 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
5021 while (++i < sd->effect_pcount2) {
5022 sd->effect_params2[i] = get_fp_val(gb);
5023 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5024 sd->effect_params2[i] / (1 << 16),
5025 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
5027 av_log(avctx, AV_LOG_DEBUG, "\n");
5030 if (sd->effect_flag = get_bits1(gb))
5031 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
5033 if (get_bits_count(gb) >= gb->size_in_bits +
5034 (avctx->codec_id == CODEC_ID_WMV3IMAGE ? 64 : 0))
5035 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
5036 if (get_bits_count(gb) < gb->size_in_bits - 8)
5037 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
5040 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
5042 int i, plane, row, sprite;
5043 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
5044 uint8_t* src_h[2][2];
5045 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
5047 MpegEncContext *s = &v->s;
5049 for (i = 0; i < 2; i++) {
5050 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
5051 xadv[i] = sd->coefs[i][0];
5052 if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
5053 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
5055 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
5056 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
5058 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
5060 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
5061 int width = v->output_width>>!!plane;
5063 for (row = 0; row < v->output_height>>!!plane; row++) {
5064 uint8_t *dst = v->sprite_output_frame.data[plane] +
5065 v->sprite_output_frame.linesize[plane] * row;
5067 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5068 uint8_t *iplane = s->current_picture.f.data[plane];
5069 int iline = s->current_picture.f.linesize[plane];
5070 int ycoord = yoff[sprite] + yadv[sprite] * row;
5071 int yline = ycoord >> 16;
5072 ysub[sprite] = ycoord & 0xFFFF;
5074 iplane = s->last_picture.f.data[plane];
5075 iline = s->last_picture.f.linesize[plane];
5077 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
5078 src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
5080 src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + (yline + 1) * iline;
5082 if (sr_cache[sprite][0] != yline) {
5083 if (sr_cache[sprite][1] == yline) {
5084 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
5085 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
5087 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
5088 sr_cache[sprite][0] = yline;
5091 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
5092 v->vc1dsp.sprite_h(v->sr_rows[sprite][1], iplane + (yline + 1) * iline, xoff[sprite], xadv[sprite], width);
5093 sr_cache[sprite][1] = yline + 1;
5095 src_h[sprite][0] = v->sr_rows[sprite][0];
5096 src_h[sprite][1] = v->sr_rows[sprite][1];
5100 if (!v->two_sprites) {
5102 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
5104 memcpy(dst, src_h[0][0], width);
5107 if (ysub[0] && ysub[1]) {
5108 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5109 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5110 } else if (ysub[0]) {
5111 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5112 src_h[1][0], alpha, width);
5113 } else if (ysub[1]) {
5114 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5115 src_h[0][0], (1<<16)-1-alpha, width);
5117 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5123 for (i = 0; i < 2; i++) {
5133 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5135 MpegEncContext *s = &v->s;
5136 AVCodecContext *avctx = s->avctx;
5139 vc1_parse_sprites(v, gb, &sd);
5141 if (!s->current_picture.f.data[0]) {
5142 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5146 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5147 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5151 if (v->sprite_output_frame.data[0])
5152 avctx->release_buffer(avctx, &v->sprite_output_frame);
5154 v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5155 v->sprite_output_frame.reference = 0;
5156 if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
5157 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5161 vc1_draw_sprites(v, &sd);
5166 static void vc1_sprite_flush(AVCodecContext *avctx)
5168 VC1Context *v = avctx->priv_data;
5169 MpegEncContext *s = &v->s;
5170 AVFrame *f = &s->current_picture.f;
5173 /* Windows Media Image codecs have a convergence interval of two keyframes.
5174 Since we can't enforce it, clear to black the missing sprite. This is
5175 wrong but it looks better than doing nothing. */
5178 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5179 for (i = 0; i < v->sprite_height>>!!plane; i++)
5180 memset(f->data[plane] + i * f->linesize[plane],
5181 plane ? 128 : 0, f->linesize[plane]);
5186 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
5188 MpegEncContext *s = &v->s;
5191 /* Allocate mb bitplanes */
5192 v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5193 v->direct_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5194 v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5195 v->fieldtx_plane = av_mallocz(s->mb_stride * s->mb_height);
5196 v->acpred_plane = av_malloc (s->mb_stride * s->mb_height);
5197 v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5199 v->n_allocated_blks = s->mb_width + 2;
5200 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5201 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5202 v->cbp = v->cbp_base + s->mb_stride;
5203 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5204 v->ttblk = v->ttblk_base + s->mb_stride;
5205 v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5206 v->is_intra = v->is_intra_base + s->mb_stride;
5207 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5208 v->luma_mv = v->luma_mv_base + s->mb_stride;
5210 /* allocate block type info in that way so it could be used with s->block_index[] */
5211 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5212 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5213 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5214 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5216 /* allocate memory to store block level MV info */
5217 v->blk_mv_type_base = av_mallocz( s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5218 v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5219 v->mv_f_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5220 v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5221 v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5222 v->mv_f_last_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5223 v->mv_f_last[0] = v->mv_f_last_base + s->b8_stride + 1;
5224 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);
5225 v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5226 v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5227 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);
5229 /* Init coded blocks info */
5230 if (v->profile == PROFILE_ADVANCED) {
5231 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5233 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5237 ff_intrax8_common_init(&v->x8,s);
5239 if (s->avctx->codec_id == CODEC_ID_WMV3IMAGE || s->avctx->codec_id == CODEC_ID_VC1IMAGE) {
5240 for (i = 0; i < 4; i++)
5241 if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5244 if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5245 !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5252 /** Initialize a VC1/WMV3 decoder
5253 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5254 * @todo TODO: Decypher remaining bits in extra_data
5256 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5258 VC1Context *v = avctx->priv_data;
5259 MpegEncContext *s = &v->s;
5263 /* save the container output size for WMImage */
5264 v->output_width = avctx->width;
5265 v->output_height = avctx->height;
5267 if (!avctx->extradata_size || !avctx->extradata)
5269 if (!(avctx->flags & CODEC_FLAG_GRAY))
5270 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5272 avctx->pix_fmt = PIX_FMT_GRAY8;
5273 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5275 avctx->flags |= CODEC_FLAG_EMU_EDGE;
5276 v->s.flags |= CODEC_FLAG_EMU_EDGE;
5278 if (avctx->idct_algo == FF_IDCT_AUTO) {
5279 avctx->idct_algo = FF_IDCT_WMV2;
5282 if (vc1_init_common(v) < 0)
5284 ff_vc1dsp_init(&v->vc1dsp);
5286 if (avctx->codec_id == CODEC_ID_WMV3 || avctx->codec_id == CODEC_ID_WMV3IMAGE) {
5289 // looks like WMV3 has a sequence header stored in the extradata
5290 // advanced sequence header may be before the first frame
5291 // the last byte of the extradata is a version number, 1 for the
5292 // samples we can decode
5294 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5296 if (vc1_decode_sequence_header(avctx, v, &gb) < 0)
5299 count = avctx->extradata_size*8 - get_bits_count(&gb);
5301 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5302 count, get_bits(&gb, count));
5303 } else if (count < 0) {
5304 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5306 } else { // VC1/WVC1/WVP2
5307 const uint8_t *start = avctx->extradata;
5308 uint8_t *end = avctx->extradata + avctx->extradata_size;
5309 const uint8_t *next;
5310 int size, buf2_size;
5311 uint8_t *buf2 = NULL;
5312 int seq_initialized = 0, ep_initialized = 0;
5314 if (avctx->extradata_size < 16) {
5315 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5319 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5320 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5322 for (; next < end; start = next) {
5323 next = find_next_marker(start + 4, end);
5324 size = next - start - 4;
5327 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5328 init_get_bits(&gb, buf2, buf2_size * 8);
5329 switch (AV_RB32(start)) {
5330 case VC1_CODE_SEQHDR:
5331 if (vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5335 seq_initialized = 1;
5337 case VC1_CODE_ENTRYPOINT:
5338 if (vc1_decode_entry_point(avctx, v, &gb) < 0) {
5347 if (!seq_initialized || !ep_initialized) {
5348 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5351 v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
5354 avctx->profile = v->profile;
5355 if (v->profile == PROFILE_ADVANCED)
5356 avctx->level = v->level;
5358 avctx->has_b_frames = !!(avctx->max_b_frames);
5360 s->mb_width = (avctx->coded_width + 15) >> 4;
5361 s->mb_height = (avctx->coded_height + 15) >> 4;
5363 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5364 for (i = 0; i < 64; i++) {
5365 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5366 v->zz_8x8[0][i] = transpose(wmv1_scantable[0][i]);
5367 v->zz_8x8[1][i] = transpose(wmv1_scantable[1][i]);
5368 v->zz_8x8[2][i] = transpose(wmv1_scantable[2][i]);
5369 v->zz_8x8[3][i] = transpose(wmv1_scantable[3][i]);
5370 v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5375 memcpy(v->zz_8x8, wmv1_scantable, 4*64);
5380 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5381 v->sprite_width = avctx->coded_width;
5382 v->sprite_height = avctx->coded_height;
5384 avctx->coded_width = avctx->width = v->output_width;
5385 avctx->coded_height = avctx->height = v->output_height;
5387 // prevent 16.16 overflows
5388 if (v->sprite_width > 1 << 14 ||
5389 v->sprite_height > 1 << 14 ||
5390 v->output_width > 1 << 14 ||
5391 v->output_height > 1 << 14) return -1;
5396 /** Close a VC1/WMV3 decoder
5397 * @warning Initial try at using MpegEncContext stuff
5399 static av_cold int vc1_decode_end(AVCodecContext *avctx)
5401 VC1Context *v = avctx->priv_data;
5404 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
5405 && v->sprite_output_frame.data[0])
5406 avctx->release_buffer(avctx, &v->sprite_output_frame);
5407 for (i = 0; i < 4; i++)
5408 av_freep(&v->sr_rows[i >> 1][i & 1]);
5409 av_freep(&v->hrd_rate);
5410 av_freep(&v->hrd_buffer);
5411 MPV_common_end(&v->s);
5412 av_freep(&v->mv_type_mb_plane);
5413 av_freep(&v->direct_mb_plane);
5414 av_freep(&v->forward_mb_plane);
5415 av_freep(&v->fieldtx_plane);
5416 av_freep(&v->acpred_plane);
5417 av_freep(&v->over_flags_plane);
5418 av_freep(&v->mb_type_base);
5419 av_freep(&v->blk_mv_type_base);
5420 av_freep(&v->mv_f_base);
5421 av_freep(&v->mv_f_last_base);
5422 av_freep(&v->mv_f_next_base);
5423 av_freep(&v->block);
5424 av_freep(&v->cbp_base);
5425 av_freep(&v->ttblk_base);
5426 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5427 av_freep(&v->luma_mv_base);
5428 ff_intrax8_common_end(&v->x8);
5433 /** Decode a VC1/WMV3 frame
5434 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5436 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5437 int *data_size, AVPacket *avpkt)
5439 const uint8_t *buf = avpkt->data;
5440 int buf_size = avpkt->size, n_slices = 0, i;
5441 VC1Context *v = avctx->priv_data;
5442 MpegEncContext *s = &v->s;
5443 AVFrame *pict = data;
5444 uint8_t *buf2 = NULL;
5445 uint8_t *buf_field2 = NULL;
5446 const uint8_t *buf_start = buf;
5447 int mb_height, n_slices1;
5454 /* no supplementary picture */
5455 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5456 /* special case for last picture */
5457 if (s->low_delay == 0 && s->next_picture_ptr) {
5458 *pict = *(AVFrame*)s->next_picture_ptr;
5459 s->next_picture_ptr = NULL;
5461 *data_size = sizeof(AVFrame);
5467 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5468 if (v->profile < PROFILE_ADVANCED)
5469 avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
5471 avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
5474 //for advanced profile we may need to parse and unescape data
5475 if (avctx->codec_id == CODEC_ID_VC1 || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5477 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5479 if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5480 const uint8_t *start, *end, *next;
5484 for (start = buf, end = buf + buf_size; next < end; start = next) {
5485 next = find_next_marker(start + 4, end);
5486 size = next - start - 4;
5487 if (size <= 0) continue;
5488 switch (AV_RB32(start)) {
5489 case VC1_CODE_FRAME:
5490 if (avctx->hwaccel ||
5491 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5493 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5495 case VC1_CODE_FIELD: {
5497 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5500 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5501 if (!slices[n_slices].buf)
5503 buf_size3 = vc1_unescape_buffer(start + 4, size,
5504 slices[n_slices].buf);
5505 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5507 /* assuming that the field marker is at the exact middle,
5508 hope it's correct */
5509 slices[n_slices].mby_start = s->mb_height >> 1;
5510 n_slices1 = n_slices - 1; // index of the last slice of the first field
5512 // not necessary, ad hoc until I find a way to handle WVC1i
5513 buf_field2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5514 vc1_unescape_buffer(start + 4, size, buf_field2);
5517 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5518 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5519 init_get_bits(&s->gb, buf2, buf_size2 * 8);
5520 vc1_decode_entry_point(avctx, v, &s->gb);
5522 case VC1_CODE_SLICE: {
5524 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5527 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5528 if (!slices[n_slices].buf)
5530 buf_size3 = vc1_unescape_buffer(start + 4, size,
5531 slices[n_slices].buf);
5532 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5534 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5540 } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5541 const uint8_t *divider;
5543 divider = find_next_marker(buf, buf + buf_size);
5544 if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5545 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5547 } else { // found field marker, unescape second field
5548 buf_field2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5549 vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, buf_field2);
5551 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5553 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5555 init_get_bits(&s->gb, buf2, buf_size2*8);
5557 init_get_bits(&s->gb, buf, buf_size*8);
5559 if (v->res_sprite) {
5560 v->new_sprite = !get_bits1(&s->gb);
5561 v->two_sprites = get_bits1(&s->gb);
5562 /* res_sprite means a Windows Media Image stream, CODEC_ID_*IMAGE means
5563 we're using the sprite compositor. These are intentionally kept separate
5564 so you can get the raw sprites by using the wmv3 decoder for WMVP or
5565 the vc1 one for WVP2 */
5566 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5567 if (v->new_sprite) {
5568 // switch AVCodecContext parameters to those of the sprites
5569 avctx->width = avctx->coded_width = v->sprite_width;
5570 avctx->height = avctx->coded_height = v->sprite_height;
5577 if (s->context_initialized &&
5578 (s->width != avctx->coded_width ||
5579 s->height != avctx->coded_height)) {
5580 vc1_decode_end(avctx);
5583 if (!s->context_initialized) {
5584 if (ff_msmpeg4_decode_init(avctx) < 0 || vc1_decode_init_alloc_tables(v) < 0)
5587 s->low_delay = !avctx->has_b_frames || v->res_sprite;
5589 if (v->profile == PROFILE_ADVANCED) {
5590 s->h_edge_pos = avctx->coded_width;
5591 s->v_edge_pos = avctx->coded_height;
5595 /* We need to set current_picture_ptr before reading the header,
5596 * otherwise we cannot store anything in there. */
5597 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5598 int i = ff_find_unused_picture(s, 0);
5599 s->current_picture_ptr = &s->picture[i];
5602 // do parse frame header
5603 v->pic_header_flag = 0;
5604 if (v->profile < PROFILE_ADVANCED) {
5605 if (vc1_parse_frame_header(v, &s->gb) == -1) {
5609 if (vc1_parse_frame_header_adv(v, &s->gb) == -1) {
5614 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
5615 && s->pict_type != AV_PICTURE_TYPE_I) {
5616 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5620 // process pulldown flags
5621 s->current_picture_ptr->f.repeat_pict = 0;
5622 // Pulldown flags are only valid when 'broadcast' has been set.
5623 // So ticks_per_frame will be 2
5626 s->current_picture_ptr->f.repeat_pict = 1;
5627 } else if (v->rptfrm) {
5629 s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5632 // for skipping the frame
5633 s->current_picture.f.pict_type = s->pict_type;
5634 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5636 /* skip B-frames if we don't have reference frames */
5637 if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
5640 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5641 (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5642 avctx->skip_frame >= AVDISCARD_ALL) {
5646 if (s->next_p_frame_damaged) {
5647 if (s->pict_type == AV_PICTURE_TYPE_B)
5650 s->next_p_frame_damaged = 0;
5653 if (MPV_frame_start(s, avctx) < 0) {
5657 s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5658 s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5660 if ((CONFIG_VC1_VDPAU_DECODER)
5661 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5662 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5663 else if (avctx->hwaccel) {
5664 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
5666 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5668 if (avctx->hwaccel->end_frame(avctx) < 0)
5671 ff_er_frame_start(s);
5673 v->bits = buf_size * 8;
5674 if (v->field_mode) {
5676 s->current_picture.f.linesize[0] <<= 1;
5677 s->current_picture.f.linesize[1] <<= 1;
5678 s->current_picture.f.linesize[2] <<= 1;
5680 s->uvlinesize <<= 1;
5681 tmp[0] = v->mv_f_last[0];
5682 tmp[1] = v->mv_f_last[1];
5683 v->mv_f_last[0] = v->mv_f_next[0];
5684 v->mv_f_last[1] = v->mv_f_next[1];
5685 v->mv_f_next[0] = v->mv_f[0];
5686 v->mv_f_next[1] = v->mv_f[1];
5687 v->mv_f[0] = tmp[0];
5688 v->mv_f[1] = tmp[1];
5690 mb_height = s->mb_height >> v->field_mode;
5691 for (i = 0; i <= n_slices; i++) {
5692 if (i > 0 && slices[i - 1].mby_start >= mb_height) {
5693 v->second_field = 1;
5694 v->blocks_off = s->mb_width * s->mb_height << 1;
5695 v->mb_off = s->mb_stride * s->mb_height >> 1;
5697 v->second_field = 0;
5702 v->pic_header_flag = 0;
5703 if (v->field_mode && i == n_slices1 + 2)
5704 vc1_parse_frame_header_adv(v, &s->gb);
5705 else if (get_bits1(&s->gb)) {
5706 v->pic_header_flag = 1;
5707 vc1_parse_frame_header_adv(v, &s->gb);
5710 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5711 if (!v->field_mode || v->second_field)
5712 s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5714 s->end_mb_y = (i == n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5715 vc1_decode_blocks(v);
5717 s->gb = slices[i].gb;
5719 if (v->field_mode) {
5720 av_free(buf_field2);
5721 v->second_field = 0;
5723 if (v->field_mode) {
5724 if (s->pict_type == AV_PICTURE_TYPE_B) {
5725 memcpy(v->mv_f_base, v->mv_f_next_base,
5726 2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5728 s->current_picture.f.linesize[0] >>= 1;
5729 s->current_picture.f.linesize[1] >>= 1;
5730 s->current_picture.f.linesize[2] >>= 1;
5732 s->uvlinesize >>= 1;
5734 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
5735 // if (get_bits_count(&s->gb) > buf_size * 8)
5742 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
5744 avctx->width = avctx->coded_width = v->output_width;
5745 avctx->height = avctx->coded_height = v->output_height;
5746 if (avctx->skip_frame >= AVDISCARD_NONREF)
5748 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5749 if (vc1_decode_sprites(v, &s->gb))
5752 *pict = v->sprite_output_frame;
5753 *data_size = sizeof(AVFrame);
5755 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5756 *pict = *(AVFrame*)s->current_picture_ptr;
5757 } else if (s->last_picture_ptr != NULL) {
5758 *pict = *(AVFrame*)s->last_picture_ptr;
5760 if (s->last_picture_ptr || s->low_delay) {
5761 *data_size = sizeof(AVFrame);
5762 ff_print_debug_info(s, pict);
5768 for (i = 0; i < n_slices; i++)
5769 av_free(slices[i].buf);
5775 for (i = 0; i < n_slices; i++)
5776 av_free(slices[i].buf);
5778 av_free(buf_field2);
5783 static const AVProfile profiles[] = {
5784 { FF_PROFILE_VC1_SIMPLE, "Simple" },
5785 { FF_PROFILE_VC1_MAIN, "Main" },
5786 { FF_PROFILE_VC1_COMPLEX, "Complex" },
5787 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5788 { FF_PROFILE_UNKNOWN },
5791 AVCodec ff_vc1_decoder = {
5793 .type = AVMEDIA_TYPE_VIDEO,
5795 .priv_data_size = sizeof(VC1Context),
5796 .init = vc1_decode_init,
5797 .close = vc1_decode_end,
5798 .decode = vc1_decode_frame,
5799 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5800 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5801 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5802 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5805 #if CONFIG_WMV3_DECODER
5806 AVCodec ff_wmv3_decoder = {
5808 .type = AVMEDIA_TYPE_VIDEO,
5809 .id = CODEC_ID_WMV3,
5810 .priv_data_size = sizeof(VC1Context),
5811 .init = vc1_decode_init,
5812 .close = vc1_decode_end,
5813 .decode = vc1_decode_frame,
5814 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5815 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5816 .pix_fmts = ff_hwaccel_pixfmt_list_420,
5817 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5821 #if CONFIG_WMV3_VDPAU_DECODER
5822 AVCodec ff_wmv3_vdpau_decoder = {
5823 .name = "wmv3_vdpau",
5824 .type = AVMEDIA_TYPE_VIDEO,
5825 .id = CODEC_ID_WMV3,
5826 .priv_data_size = sizeof(VC1Context),
5827 .init = vc1_decode_init,
5828 .close = vc1_decode_end,
5829 .decode = vc1_decode_frame,
5830 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5831 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5832 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE},
5833 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5837 #if CONFIG_VC1_VDPAU_DECODER
5838 AVCodec ff_vc1_vdpau_decoder = {
5839 .name = "vc1_vdpau",
5840 .type = AVMEDIA_TYPE_VIDEO,
5842 .priv_data_size = sizeof(VC1Context),
5843 .init = vc1_decode_init,
5844 .close = vc1_decode_end,
5845 .decode = vc1_decode_frame,
5846 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5847 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5848 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE},
5849 .profiles = NULL_IF_CONFIG_SMALL(profiles)
5853 #if CONFIG_WMV3IMAGE_DECODER
5854 AVCodec ff_wmv3image_decoder = {
5855 .name = "wmv3image",
5856 .type = AVMEDIA_TYPE_VIDEO,
5857 .id = CODEC_ID_WMV3IMAGE,
5858 .priv_data_size = sizeof(VC1Context),
5859 .init = vc1_decode_init,
5860 .close = vc1_decode_end,
5861 .decode = vc1_decode_frame,
5862 .capabilities = CODEC_CAP_DR1,
5863 .flush = vc1_sprite_flush,
5864 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5865 .pix_fmts = ff_pixfmt_list_420
5869 #if CONFIG_VC1IMAGE_DECODER
5870 AVCodec ff_vc1image_decoder = {
5872 .type = AVMEDIA_TYPE_VIDEO,
5873 .id = CODEC_ID_VC1IMAGE,
5874 .priv_data_size = sizeof(VC1Context),
5875 .init = vc1_decode_init,
5876 .close = vc1_decode_end,
5877 .decode = vc1_decode_frame,
5878 .capabilities = CODEC_CAP_DR1,
5879 .flush = vc1_sprite_flush,
5880 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5881 .pix_fmts = ff_pixfmt_list_420