2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2006-2007 Konstantin Shishkov
4 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
6 * This file is part of Libav.
8 * Libav is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * Libav is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * VC-1 and WMV3 decoder
31 #include "mpegvideo.h"
35 #include "vc1acdata.h"
36 #include "msmpeg4data.h"
38 #include "simple_idct.h"
40 #include "vdpau_internal.h"
45 #define MB_INTRA_VLC_BITS 9
50 static const uint16_t vlc_offs[] = {
51 0, 520, 552, 616, 1128, 1160, 1224, 1740, 1772, 1836, 1900, 2436,
52 2986, 3050, 3610, 4154, 4218, 4746, 5326, 5390, 5902, 6554, 7658, 8620,
53 9262, 10202, 10756, 11310, 12228, 15078
57 * Init VC-1 specific tables and VC1Context members
58 * @param v The VC1Context to initialize
61 static int vc1_init_common(VC1Context *v)
65 static VLC_TYPE vlc_table[15078][2];
67 v->hrd_rate = v->hrd_buffer = NULL;
72 INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
73 ff_vc1_bfraction_bits, 1, 1,
74 ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
75 INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
76 ff_vc1_norm2_bits, 1, 1,
77 ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
78 INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
79 ff_vc1_norm6_bits, 1, 1,
80 ff_vc1_norm6_codes, 2, 2, 556);
81 INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
82 ff_vc1_imode_bits, 1, 1,
83 ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
86 ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i*3+0]];
87 ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i*3+1] - vlc_offs[i*3+0];
88 init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
89 ff_vc1_ttmb_bits[i], 1, 1,
90 ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
91 ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i*3+1]];
92 ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i*3+2] - vlc_offs[i*3+1];
93 init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
94 ff_vc1_ttblk_bits[i], 1, 1,
95 ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
96 ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i*3+2]];
97 ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i*3+3] - vlc_offs[i*3+2];
98 init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
99 ff_vc1_subblkpat_bits[i], 1, 1,
100 ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
104 ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i*3+9]];
105 ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i*3+10] - vlc_offs[i*3+9];
106 init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
107 ff_vc1_4mv_block_pattern_bits[i], 1, 1,
108 ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
109 ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i*3+10]];
110 ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i*3+11] - vlc_offs[i*3+10];
111 init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
112 ff_vc1_cbpcy_p_bits[i], 1, 1,
113 ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
114 ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i*3+11]];
115 ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i*3+12] - vlc_offs[i*3+11];
116 init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
117 ff_vc1_mv_diff_bits[i], 1, 1,
118 ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
121 ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i+21]];
122 ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i+22] - vlc_offs[i+21];
123 init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
124 &vc1_ac_tables[i][0][1], 8, 4,
125 &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
132 v->mvrange = 0; /* 7.1.1.18, p80 */
137 /***********************************************************************/
139 * @name VC-1 Bitplane decoding
157 /** @} */ //imode defines
160 /** @} */ //Bitplane group
162 static void vc1_put_signed_blocks_clamped(VC1Context *v)
164 MpegEncContext *s = &v->s;
166 /* The put pixels loop is always one MB row behind the decoding loop,
167 * because we can only put pixels when overlap filtering is done, and
168 * for filtering of the bottom edge of a MB, we need the next MB row
170 * Within the row, the put pixels loop is also one MB col behind the
171 * decoding loop. The reason for this is again, because for filtering
172 * of the right MB edge, we need the next MB present. */
173 if (!s->first_slice_line) {
175 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
176 s->dest[0] - 16 * s->linesize - 16,
178 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
179 s->dest[0] - 16 * s->linesize - 8,
181 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
182 s->dest[0] - 8 * s->linesize - 16,
184 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
185 s->dest[0] - 8 * s->linesize - 8,
187 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
188 s->dest[1] - 8 * s->uvlinesize - 8,
190 s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
191 s->dest[2] - 8 * s->uvlinesize - 8,
194 if (s->mb_x == s->mb_width - 1) {
195 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
196 s->dest[0] - 16 * s->linesize,
198 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
199 s->dest[0] - 16 * s->linesize + 8,
201 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
202 s->dest[0] - 8 * s->linesize,
204 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
205 s->dest[0] - 8 * s->linesize + 8,
207 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
208 s->dest[1] - 8 * s->uvlinesize,
210 s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
211 s->dest[2] - 8 * s->uvlinesize,
216 #define inc_blk_idx(idx) do { \
218 if (idx >= v->n_allocated_blks) \
222 inc_blk_idx(v->topleft_blk_idx);
223 inc_blk_idx(v->top_blk_idx);
224 inc_blk_idx(v->left_blk_idx);
225 inc_blk_idx(v->cur_blk_idx);
228 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
230 MpegEncContext *s = &v->s;
232 if (!s->first_slice_line) {
233 v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
235 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16*s->linesize, s->linesize, pq);
236 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16*s->linesize+8, s->linesize, pq);
237 for(j = 0; j < 2; j++){
238 v->vc1dsp.vc1_v_loop_filter8(s->dest[j+1], s->uvlinesize, pq);
240 v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1]-8*s->uvlinesize, s->uvlinesize, pq);
243 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8*s->linesize, s->linesize, pq);
245 if (s->mb_y == s->mb_height-1) {
247 v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
248 v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
249 v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
251 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
255 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
257 MpegEncContext *s = &v->s;
260 /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
261 * means it runs two rows/cols behind the decoding loop. */
262 if (!s->first_slice_line) {
264 if (s->mb_y >= s->start_mb_y + 2) {
265 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
268 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
269 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
270 for(j = 0; j < 2; j++) {
271 v->vc1dsp.vc1_v_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
273 v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
277 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
280 if (s->mb_x == s->mb_width - 1) {
281 if (s->mb_y >= s->start_mb_y + 2) {
282 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
285 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
286 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
287 for(j = 0; j < 2; j++) {
288 v->vc1dsp.vc1_v_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize, s->uvlinesize, pq);
290 v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 16 * s->uvlinesize, s->uvlinesize, pq);
294 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
297 if (s->mb_y == s->mb_height) {
300 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
301 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
303 for(j = 0; j < 2; j++) {
304 v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
309 if (s->mb_x == s->mb_width - 1) {
311 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
312 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
314 for(j = 0; j < 2; j++) {
315 v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize, s->uvlinesize, pq);
323 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
325 MpegEncContext *s = &v->s;
328 if (v->condover == CONDOVER_NONE)
331 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
333 /* Within a MB, the horizontal overlap always runs before the vertical.
334 * To accomplish that, we run the H on left and internal borders of the
335 * currently decoded MB. Then, we wait for the next overlap iteration
336 * to do H overlap on the right edge of this MB, before moving over and
337 * running the V overlap. Therefore, the V overlap makes us trail by one
338 * MB col and the H overlap filter makes us trail by one MB row. This
339 * is reflected in the time at which we run the put_pixels loop. */
340 if(v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
341 if(s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
342 v->over_flags_plane[mb_pos - 1])) {
343 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
344 v->block[v->cur_blk_idx][0]);
345 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
346 v->block[v->cur_blk_idx][2]);
347 if(!(s->flags & CODEC_FLAG_GRAY)) {
348 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
349 v->block[v->cur_blk_idx][4]);
350 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
351 v->block[v->cur_blk_idx][5]);
354 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
355 v->block[v->cur_blk_idx][1]);
356 v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
357 v->block[v->cur_blk_idx][3]);
359 if (s->mb_x == s->mb_width - 1) {
360 if(!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
361 v->over_flags_plane[mb_pos - s->mb_stride])) {
362 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
363 v->block[v->cur_blk_idx][0]);
364 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
365 v->block[v->cur_blk_idx][1]);
366 if(!(s->flags & CODEC_FLAG_GRAY)) {
367 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
368 v->block[v->cur_blk_idx][4]);
369 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
370 v->block[v->cur_blk_idx][5]);
373 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
374 v->block[v->cur_blk_idx][2]);
375 v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
376 v->block[v->cur_blk_idx][3]);
379 if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
380 if(!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
381 v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
382 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
383 v->block[v->left_blk_idx][0]);
384 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
385 v->block[v->left_blk_idx][1]);
386 if(!(s->flags & CODEC_FLAG_GRAY)) {
387 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
388 v->block[v->left_blk_idx][4]);
389 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
390 v->block[v->left_blk_idx][5]);
393 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
394 v->block[v->left_blk_idx][2]);
395 v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
396 v->block[v->left_blk_idx][3]);
400 /** Do motion compensation over 1 macroblock
401 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
403 static void vc1_mc_1mv(VC1Context *v, int dir)
405 MpegEncContext *s = &v->s;
406 DSPContext *dsp = &v->s.dsp;
407 uint8_t *srcY, *srcU, *srcV;
408 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
410 if(!v->s.last_picture.f.data[0])return;
412 mx = s->mv[dir][0][0];
413 my = s->mv[dir][0][1];
415 // store motion vectors for further use in B frames
416 if(s->pict_type == AV_PICTURE_TYPE_P) {
417 s->current_picture.f.motion_val[1][s->block_index[0]][0] = mx;
418 s->current_picture.f.motion_val[1][s->block_index[0]][1] = my;
420 uvmx = (mx + ((mx & 3) == 3)) >> 1;
421 uvmy = (my + ((my & 3) == 3)) >> 1;
422 v->luma_mv[s->mb_x][0] = uvmx;
423 v->luma_mv[s->mb_x][1] = uvmy;
425 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
426 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
429 srcY = s->last_picture.f.data[0];
430 srcU = s->last_picture.f.data[1];
431 srcV = s->last_picture.f.data[2];
433 srcY = s->next_picture.f.data[0];
434 srcU = s->next_picture.f.data[1];
435 srcV = s->next_picture.f.data[2];
438 src_x = s->mb_x * 16 + (mx >> 2);
439 src_y = s->mb_y * 16 + (my >> 2);
440 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
441 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
443 if(v->profile != PROFILE_ADVANCED){
444 src_x = av_clip( src_x, -16, s->mb_width * 16);
445 src_y = av_clip( src_y, -16, s->mb_height * 16);
446 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
447 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
449 src_x = av_clip( src_x, -17, s->avctx->coded_width);
450 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
451 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
452 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
455 srcY += src_y * s->linesize + src_x;
456 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
457 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
459 /* for grayscale we should not try to read from unknown area */
460 if(s->flags & CODEC_FLAG_GRAY) {
461 srcU = s->edge_emu_buffer + 18 * s->linesize;
462 srcV = s->edge_emu_buffer + 18 * s->linesize;
465 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
466 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
467 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
468 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
470 srcY -= s->mspel * (1 + s->linesize);
471 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
472 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
473 srcY = s->edge_emu_buffer;
474 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
475 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
476 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
477 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
480 /* if we deal with range reduction we need to scale source blocks */
486 for(j = 0; j < 17 + s->mspel*2; j++) {
487 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
490 src = srcU; src2 = srcV;
491 for(j = 0; j < 9; j++) {
492 for(i = 0; i < 9; i++) {
493 src[i] = ((src[i] - 128) >> 1) + 128;
494 src2[i] = ((src2[i] - 128) >> 1) + 128;
496 src += s->uvlinesize;
497 src2 += s->uvlinesize;
500 /* if we deal with intensity compensation we need to scale source blocks */
501 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
506 for(j = 0; j < 17 + s->mspel*2; j++) {
507 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
510 src = srcU; src2 = srcV;
511 for(j = 0; j < 9; j++) {
512 for(i = 0; i < 9; i++) {
513 src[i] = v->lutuv[src[i]];
514 src2[i] = v->lutuv[src2[i]];
516 src += s->uvlinesize;
517 src2 += s->uvlinesize;
520 srcY += s->mspel * (1 + s->linesize);
524 dxy = ((my & 3) << 2) | (mx & 3);
525 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
526 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
527 srcY += s->linesize * 8;
528 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
529 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
530 } else { // hpel mc - always used for luma
531 dxy = (my & 2) | ((mx & 2) >> 1);
534 dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
536 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
539 if(s->flags & CODEC_FLAG_GRAY) return;
540 /* Chroma MC always uses qpel bilinear */
544 dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
545 dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
547 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
548 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
552 /** Do motion compensation for 4-MV macroblock - luminance block
554 static void vc1_mc_4mv_luma(VC1Context *v, int n)
556 MpegEncContext *s = &v->s;
557 DSPContext *dsp = &v->s.dsp;
559 int dxy, mx, my, src_x, src_y;
562 if(!v->s.last_picture.f.data[0])return;
565 srcY = s->last_picture.f.data[0];
567 off = s->linesize * 4 * (n&2) + (n&1) * 8;
569 src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
570 src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
572 if(v->profile != PROFILE_ADVANCED){
573 src_x = av_clip( src_x, -16, s->mb_width * 16);
574 src_y = av_clip( src_y, -16, s->mb_height * 16);
576 src_x = av_clip( src_x, -17, s->avctx->coded_width);
577 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
580 srcY += src_y * s->linesize + src_x;
582 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
583 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
584 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
585 srcY -= s->mspel * (1 + s->linesize);
586 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
587 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
588 srcY = s->edge_emu_buffer;
589 /* if we deal with range reduction we need to scale source blocks */
595 for(j = 0; j < 9 + s->mspel*2; j++) {
596 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
600 /* if we deal with intensity compensation we need to scale source blocks */
601 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
606 for(j = 0; j < 9 + s->mspel*2; j++) {
607 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
611 srcY += s->mspel * (1 + s->linesize);
615 dxy = ((my & 3) << 2) | (mx & 3);
616 v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
617 } else { // hpel mc - always used for luma
618 dxy = (my & 2) | ((mx & 2) >> 1);
620 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
622 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
626 static inline int median4(int a, int b, int c, int d)
629 if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
630 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
632 if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
633 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
638 /** Do motion compensation for 4-MV macroblock - both chroma blocks
640 static void vc1_mc_4mv_chroma(VC1Context *v)
642 MpegEncContext *s = &v->s;
643 DSPContext *dsp = &v->s.dsp;
644 uint8_t *srcU, *srcV;
645 int uvmx, uvmy, uvsrc_x, uvsrc_y;
646 int i, idx, tx = 0, ty = 0;
647 int mvx[4], mvy[4], intra[4];
648 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
650 if(!v->s.last_picture.f.data[0])return;
651 if(s->flags & CODEC_FLAG_GRAY) return;
653 for(i = 0; i < 4; i++) {
654 mvx[i] = s->mv[0][i][0];
655 mvy[i] = s->mv[0][i][1];
656 intra[i] = v->mb_type[0][s->block_index[i]];
659 /* calculate chroma MV vector from four luma MVs */
660 idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
661 if(!idx) { // all blocks are inter
662 tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
663 ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
664 } else if(count[idx] == 1) { // 3 inter blocks
667 tx = mid_pred(mvx[1], mvx[2], mvx[3]);
668 ty = mid_pred(mvy[1], mvy[2], mvy[3]);
671 tx = mid_pred(mvx[0], mvx[2], mvx[3]);
672 ty = mid_pred(mvy[0], mvy[2], mvy[3]);
675 tx = mid_pred(mvx[0], mvx[1], mvx[3]);
676 ty = mid_pred(mvy[0], mvy[1], mvy[3]);
679 tx = mid_pred(mvx[0], mvx[1], mvx[2]);
680 ty = mid_pred(mvy[0], mvy[1], mvy[2]);
683 } else if(count[idx] == 2) {
685 for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
686 for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
687 tx = (mvx[t1] + mvx[t2]) / 2;
688 ty = (mvy[t1] + mvy[t2]) / 2;
690 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
691 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
692 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
693 return; //no need to do MC for inter blocks
696 s->current_picture.f.motion_val[1][s->block_index[0]][0] = tx;
697 s->current_picture.f.motion_val[1][s->block_index[0]][1] = ty;
698 uvmx = (tx + ((tx&3) == 3)) >> 1;
699 uvmy = (ty + ((ty&3) == 3)) >> 1;
700 v->luma_mv[s->mb_x][0] = uvmx;
701 v->luma_mv[s->mb_x][1] = uvmy;
703 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
704 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
707 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
708 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
710 if(v->profile != PROFILE_ADVANCED){
711 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
712 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
714 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
715 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
718 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
719 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
720 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
721 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
722 || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
723 s->dsp.emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize, 8+1, 8+1,
724 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
725 s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
726 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
727 srcU = s->edge_emu_buffer;
728 srcV = s->edge_emu_buffer + 16;
730 /* if we deal with range reduction we need to scale source blocks */
735 src = srcU; src2 = srcV;
736 for(j = 0; j < 9; j++) {
737 for(i = 0; i < 9; i++) {
738 src[i] = ((src[i] - 128) >> 1) + 128;
739 src2[i] = ((src2[i] - 128) >> 1) + 128;
741 src += s->uvlinesize;
742 src2 += s->uvlinesize;
745 /* if we deal with intensity compensation we need to scale source blocks */
746 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
750 src = srcU; src2 = srcV;
751 for(j = 0; j < 9; j++) {
752 for(i = 0; i < 9; i++) {
753 src[i] = v->lutuv[src[i]];
754 src2[i] = v->lutuv[src2[i]];
756 src += s->uvlinesize;
757 src2 += s->uvlinesize;
762 /* Chroma MC always uses qpel bilinear */
766 dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
767 dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
769 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
770 v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
774 /***********************************************************************/
776 * @name VC-1 Block-level functions
777 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
783 * @brief Get macroblock-level quantizer scale
785 #define GET_MQUANT() \
789 if (v->dqprofile == DQPROFILE_ALL_MBS) \
793 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
797 mqdiff = get_bits(gb, 3); \
798 if (mqdiff != 7) mquant = v->pq + mqdiff; \
799 else mquant = get_bits(gb, 5); \
802 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
803 edges = 1 << v->dqsbedge; \
804 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
805 edges = (3 << v->dqsbedge) % 15; \
806 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
808 if((edges&1) && !s->mb_x) \
810 if((edges&2) && s->first_slice_line) \
812 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
814 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
819 * @def GET_MVDATA(_dmv_x, _dmv_y)
820 * @brief Get MV differentials
821 * @see MVDATA decoding from 8.3.5.2, p(1)20
822 * @param _dmv_x Horizontal differential for decoded MV
823 * @param _dmv_y Vertical differential for decoded MV
825 #define GET_MVDATA(_dmv_x, _dmv_y) \
826 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table,\
827 VC1_MV_DIFF_VLC_BITS, 2); \
833 else mb_has_coeffs = 0; \
835 if (!index) { _dmv_x = _dmv_y = 0; } \
836 else if (index == 35) \
838 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
839 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
841 else if (index == 36) \
850 if (!s->quarter_sample && index1 == 5) val = 1; \
852 if(size_table[index1] - val > 0) \
853 val = get_bits(gb, size_table[index1] - val); \
855 sign = 0 - (val&1); \
856 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
859 if (!s->quarter_sample && index1 == 5) val = 1; \
861 if(size_table[index1] - val > 0) \
862 val = get_bits(gb, size_table[index1] - val); \
864 sign = 0 - (val&1); \
865 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
868 /** Predict and set motion vector
870 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, int mv1, int r_x, int r_y, uint8_t* is_intra)
872 MpegEncContext *s = &v->s;
873 int xy, wrap, off = 0;
878 /* scale MV difference to be quad-pel */
879 dmv_x <<= 1 - s->quarter_sample;
880 dmv_y <<= 1 - s->quarter_sample;
883 xy = s->block_index[n];
886 s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
887 s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
888 s->current_picture.f.motion_val[1][xy][0] = 0;
889 s->current_picture.f.motion_val[1][xy][1] = 0;
890 if(mv1) { /* duplicate motion data for 1-MV block */
891 s->current_picture.f.motion_val[0][xy + 1][0] = 0;
892 s->current_picture.f.motion_val[0][xy + 1][1] = 0;
893 s->current_picture.f.motion_val[0][xy + wrap][0] = 0;
894 s->current_picture.f.motion_val[0][xy + wrap][1] = 0;
895 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
896 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
897 v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
898 s->current_picture.f.motion_val[1][xy + 1][0] = 0;
899 s->current_picture.f.motion_val[1][xy + 1][1] = 0;
900 s->current_picture.f.motion_val[1][xy + wrap][0] = 0;
901 s->current_picture.f.motion_val[1][xy + wrap][1] = 0;
902 s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
903 s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
908 C = s->current_picture.f.motion_val[0][xy - 1];
909 A = s->current_picture.f.motion_val[0][xy - wrap];
911 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
913 //in 4-MV mode different blocks have different B predictor position
916 off = (s->mb_x > 0) ? -1 : 1;
919 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
928 B = s->current_picture.f.motion_val[0][xy - wrap + off];
930 if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
931 if(s->mb_width == 1) {
935 px = mid_pred(A[0], B[0], C[0]);
936 py = mid_pred(A[1], B[1], C[1]);
938 } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
944 /* Pullback MV as specified in 8.3.5.3.4 */
947 qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
948 qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
949 X = (s->mb_width << 6) - 4;
950 Y = (s->mb_height << 6) - 4;
952 if(qx + px < -60) px = -60 - qx;
953 if(qy + py < -60) py = -60 - qy;
955 if(qx + px < -28) px = -28 - qx;
956 if(qy + py < -28) py = -28 - qy;
958 if(qx + px > X) px = X - qx;
959 if(qy + py > Y) py = Y - qy;
961 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
962 if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
963 if(is_intra[xy - wrap])
964 sum = FFABS(px) + FFABS(py);
966 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
968 if(get_bits1(&s->gb)) {
977 sum = FFABS(px) + FFABS(py);
979 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
981 if(get_bits1(&s->gb)) {
991 /* store MV using signed modulus of MV range defined in 4.11 */
992 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;
993 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;
994 if(mv1) { /* duplicate motion data for 1-MV block */
995 s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
996 s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
997 s->current_picture.f.motion_val[0][xy + wrap][0] = s->current_picture.f.motion_val[0][xy][0];
998 s->current_picture.f.motion_val[0][xy + wrap][1] = s->current_picture.f.motion_val[0][xy][1];
999 s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1000 s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1004 /** Motion compensation for direct or interpolated blocks in B-frames
1006 static void vc1_interp_mc(VC1Context *v)
1008 MpegEncContext *s = &v->s;
1009 DSPContext *dsp = &v->s.dsp;
1010 uint8_t *srcY, *srcU, *srcV;
1011 int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1013 if(!v->s.next_picture.f.data[0])return;
1015 mx = s->mv[1][0][0];
1016 my = s->mv[1][0][1];
1017 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1018 uvmy = (my + ((my & 3) == 3)) >> 1;
1020 uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
1021 uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
1023 srcY = s->next_picture.f.data[0];
1024 srcU = s->next_picture.f.data[1];
1025 srcV = s->next_picture.f.data[2];
1027 src_x = s->mb_x * 16 + (mx >> 2);
1028 src_y = s->mb_y * 16 + (my >> 2);
1029 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1030 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1032 if(v->profile != PROFILE_ADVANCED){
1033 src_x = av_clip( src_x, -16, s->mb_width * 16);
1034 src_y = av_clip( src_y, -16, s->mb_height * 16);
1035 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1036 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1038 src_x = av_clip( src_x, -17, s->avctx->coded_width);
1039 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1040 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1041 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1044 srcY += src_y * s->linesize + src_x;
1045 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1046 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1048 /* for grayscale we should not try to read from unknown area */
1049 if(s->flags & CODEC_FLAG_GRAY) {
1050 srcU = s->edge_emu_buffer + 18 * s->linesize;
1051 srcV = s->edge_emu_buffer + 18 * s->linesize;
1055 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
1056 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
1057 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
1059 srcY -= s->mspel * (1 + s->linesize);
1060 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
1061 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
1062 srcY = s->edge_emu_buffer;
1063 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
1064 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1065 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
1066 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1069 /* if we deal with range reduction we need to scale source blocks */
1070 if(v->rangeredfrm) {
1072 uint8_t *src, *src2;
1075 for(j = 0; j < 17 + s->mspel*2; j++) {
1076 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
1079 src = srcU; src2 = srcV;
1080 for(j = 0; j < 9; j++) {
1081 for(i = 0; i < 9; i++) {
1082 src[i] = ((src[i] - 128) >> 1) + 128;
1083 src2[i] = ((src2[i] - 128) >> 1) + 128;
1085 src += s->uvlinesize;
1086 src2 += s->uvlinesize;
1089 srcY += s->mspel * (1 + s->linesize);
1093 dxy = ((my & 3) << 2) | (mx & 3);
1094 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
1095 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
1096 srcY += s->linesize * 8;
1097 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
1098 v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1100 dxy = (my & 2) | ((mx & 2) >> 1);
1103 dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
1105 dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
1108 if(s->flags & CODEC_FLAG_GRAY) return;
1109 /* Chroma MC always uses qpel blilinear */
1113 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1114 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1116 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1117 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1121 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1125 #if B_FRACTION_DEN==256
1129 return 2 * ((value * n + 255) >> 9);
1130 return (value * n + 128) >> 8;
1133 n -= B_FRACTION_DEN;
1135 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1136 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1140 /** Reconstruct motion vector for B-frame and do motion compensation
1142 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
1145 v->mv_mode2 = v->mv_mode;
1146 v->mv_mode = MV_PMODE_INTENSITY_COMP;
1151 if(v->use_ic) v->mv_mode = v->mv_mode2;
1154 if(mode == BMV_TYPE_INTERPOLATED) {
1157 if(v->use_ic) v->mv_mode = v->mv_mode2;
1161 if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
1162 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
1163 if(v->use_ic) v->mv_mode = v->mv_mode2;
1166 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
1168 MpegEncContext *s = &v->s;
1169 int xy, wrap, off = 0;
1174 const uint8_t *is_intra = v->mb_type[0];
1178 /* scale MV difference to be quad-pel */
1179 dmv_x[0] <<= 1 - s->quarter_sample;
1180 dmv_y[0] <<= 1 - s->quarter_sample;
1181 dmv_x[1] <<= 1 - s->quarter_sample;
1182 dmv_y[1] <<= 1 - s->quarter_sample;
1184 wrap = s->b8_stride;
1185 xy = s->block_index[0];
1188 s->current_picture.f.motion_val[0][xy][0] =
1189 s->current_picture.f.motion_val[0][xy][1] =
1190 s->current_picture.f.motion_val[1][xy][0] =
1191 s->current_picture.f.motion_val[1][xy][1] = 0;
1194 s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
1195 s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
1196 s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
1197 s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
1199 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
1200 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));
1201 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));
1202 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));
1203 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));
1205 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
1206 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
1207 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
1208 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
1212 if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
1213 C = s->current_picture.f.motion_val[0][xy - 2];
1214 A = s->current_picture.f.motion_val[0][xy - wrap*2];
1215 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1216 B = s->current_picture.f.motion_val[0][xy - wrap*2 + off];
1218 if(!s->mb_x) C[0] = C[1] = 0;
1219 if(!s->first_slice_line) { // predictor A is not out of bounds
1220 if(s->mb_width == 1) {
1224 px = mid_pred(A[0], B[0], C[0]);
1225 py = mid_pred(A[1], B[1], C[1]);
1227 } else if(s->mb_x) { // predictor C is not out of bounds
1233 /* Pullback MV as specified in 8.3.5.3.4 */
1236 if(v->profile < PROFILE_ADVANCED) {
1237 qx = (s->mb_x << 5);
1238 qy = (s->mb_y << 5);
1239 X = (s->mb_width << 5) - 4;
1240 Y = (s->mb_height << 5) - 4;
1241 if(qx + px < -28) px = -28 - qx;
1242 if(qy + py < -28) py = -28 - qy;
1243 if(qx + px > X) px = X - qx;
1244 if(qy + py > Y) py = Y - qy;
1246 qx = (s->mb_x << 6);
1247 qy = (s->mb_y << 6);
1248 X = (s->mb_width << 6) - 4;
1249 Y = (s->mb_height << 6) - 4;
1250 if(qx + px < -60) px = -60 - qx;
1251 if(qy + py < -60) py = -60 - qy;
1252 if(qx + px > X) px = X - qx;
1253 if(qy + py > Y) py = Y - qy;
1256 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1257 if(0 && !s->first_slice_line && s->mb_x) {
1258 if(is_intra[xy - wrap])
1259 sum = FFABS(px) + FFABS(py);
1261 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
1263 if(get_bits1(&s->gb)) {
1271 if(is_intra[xy - 2])
1272 sum = FFABS(px) + FFABS(py);
1274 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
1276 if(get_bits1(&s->gb)) {
1286 /* store MV using signed modulus of MV range defined in 4.11 */
1287 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
1288 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
1290 if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
1291 C = s->current_picture.f.motion_val[1][xy - 2];
1292 A = s->current_picture.f.motion_val[1][xy - wrap*2];
1293 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1294 B = s->current_picture.f.motion_val[1][xy - wrap*2 + off];
1296 if(!s->mb_x) C[0] = C[1] = 0;
1297 if(!s->first_slice_line) { // predictor A is not out of bounds
1298 if(s->mb_width == 1) {
1302 px = mid_pred(A[0], B[0], C[0]);
1303 py = mid_pred(A[1], B[1], C[1]);
1305 } else if(s->mb_x) { // predictor C is not out of bounds
1311 /* Pullback MV as specified in 8.3.5.3.4 */
1314 if(v->profile < PROFILE_ADVANCED) {
1315 qx = (s->mb_x << 5);
1316 qy = (s->mb_y << 5);
1317 X = (s->mb_width << 5) - 4;
1318 Y = (s->mb_height << 5) - 4;
1319 if(qx + px < -28) px = -28 - qx;
1320 if(qy + py < -28) py = -28 - qy;
1321 if(qx + px > X) px = X - qx;
1322 if(qy + py > Y) py = Y - qy;
1324 qx = (s->mb_x << 6);
1325 qy = (s->mb_y << 6);
1326 X = (s->mb_width << 6) - 4;
1327 Y = (s->mb_height << 6) - 4;
1328 if(qx + px < -60) px = -60 - qx;
1329 if(qy + py < -60) py = -60 - qy;
1330 if(qx + px > X) px = X - qx;
1331 if(qy + py > Y) py = Y - qy;
1334 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1335 if(0 && !s->first_slice_line && s->mb_x) {
1336 if(is_intra[xy - wrap])
1337 sum = FFABS(px) + FFABS(py);
1339 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
1341 if(get_bits1(&s->gb)) {
1349 if(is_intra[xy - 2])
1350 sum = FFABS(px) + FFABS(py);
1352 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
1354 if(get_bits1(&s->gb)) {
1364 /* store MV using signed modulus of MV range defined in 4.11 */
1366 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
1367 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
1369 s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
1370 s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
1371 s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
1372 s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
1375 /** Get predicted DC value for I-frames only
1376 * prediction dir: left=0, top=1
1377 * @param s MpegEncContext
1378 * @param overlap flag indicating that overlap filtering is used
1379 * @param pq integer part of picture quantizer
1380 * @param[in] n block index in the current MB
1381 * @param dc_val_ptr Pointer to DC predictor
1382 * @param dir_ptr Prediction direction for use in AC prediction
1384 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1385 int16_t **dc_val_ptr, int *dir_ptr)
1387 int a, b, c, wrap, pred, scale;
1389 static const uint16_t dcpred[32] = {
1390 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
1391 114, 102, 93, 85, 79, 73, 68, 64,
1392 60, 57, 54, 51, 49, 47, 45, 43,
1393 41, 39, 38, 37, 35, 34, 33
1396 /* find prediction - wmv3_dc_scale always used here in fact */
1397 if (n < 4) scale = s->y_dc_scale;
1398 else scale = s->c_dc_scale;
1400 wrap = s->block_wrap[n];
1401 dc_val= s->dc_val[0] + s->block_index[n];
1407 b = dc_val[ - 1 - wrap];
1408 a = dc_val[ - wrap];
1410 if (pq < 9 || !overlap)
1412 /* Set outer values */
1413 if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
1414 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1418 /* Set outer values */
1419 if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
1420 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1423 if (abs(a - b) <= abs(b - c)) {
1431 /* update predictor */
1432 *dc_val_ptr = &dc_val[0];
1437 /** Get predicted DC value
1438 * prediction dir: left=0, top=1
1439 * @param s MpegEncContext
1440 * @param overlap flag indicating that overlap filtering is used
1441 * @param pq integer part of picture quantizer
1442 * @param[in] n block index in the current MB
1443 * @param a_avail flag indicating top block availability
1444 * @param c_avail flag indicating left block availability
1445 * @param dc_val_ptr Pointer to DC predictor
1446 * @param dir_ptr Prediction direction for use in AC prediction
1448 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1449 int a_avail, int c_avail,
1450 int16_t **dc_val_ptr, int *dir_ptr)
1452 int a, b, c, wrap, pred;
1454 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1457 wrap = s->block_wrap[n];
1458 dc_val= s->dc_val[0] + s->block_index[n];
1464 b = dc_val[ - 1 - wrap];
1465 a = dc_val[ - wrap];
1466 /* scale predictors if needed */
1467 q1 = s->current_picture.f.qscale_table[mb_pos];
1468 if(c_avail && (n!= 1 && n!=3)) {
1469 q2 = s->current_picture.f.qscale_table[mb_pos - 1];
1471 c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1473 if(a_avail && (n!= 2 && n!=3)) {
1474 q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
1476 a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1478 if(a_avail && c_avail && (n!=3)) {
1481 if(n != 2) off -= s->mb_stride;
1482 q2 = s->current_picture.f.qscale_table[off];
1484 b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1487 if(a_avail && c_avail) {
1488 if(abs(a - b) <= abs(b - c)) {
1495 } else if(a_avail) {
1498 } else if(c_avail) {
1506 /* update predictor */
1507 *dc_val_ptr = &dc_val[0];
1511 /** @} */ // Block group
1514 * @name VC1 Macroblock-level functions in Simple/Main Profiles
1515 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1519 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1521 int xy, wrap, pred, a, b, c;
1523 xy = s->block_index[n];
1524 wrap = s->b8_stride;
1529 a = s->coded_block[xy - 1 ];
1530 b = s->coded_block[xy - 1 - wrap];
1531 c = s->coded_block[xy - wrap];
1540 *coded_block_ptr = &s->coded_block[xy];
1546 * Decode one AC coefficient
1547 * @param v The VC1 context
1548 * @param last Last coefficient
1549 * @param skip How much zero coefficients to skip
1550 * @param value Decoded AC coefficient value
1551 * @param codingset set of VLC to decode data
1554 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
1556 GetBitContext *gb = &v->s.gb;
1557 int index, escape, run = 0, level = 0, lst = 0;
1559 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1560 if (index != vc1_ac_sizes[codingset] - 1) {
1561 run = vc1_index_decode_table[codingset][index][0];
1562 level = vc1_index_decode_table[codingset][index][1];
1563 lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
1567 escape = decode210(gb);
1569 index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1570 run = vc1_index_decode_table[codingset][index][0];
1571 level = vc1_index_decode_table[codingset][index][1];
1572 lst = index >= vc1_last_decode_table[codingset];
1575 level += vc1_last_delta_level_table[codingset][run];
1577 level += vc1_delta_level_table[codingset][run];
1580 run += vc1_last_delta_run_table[codingset][level] + 1;
1582 run += vc1_delta_run_table[codingset][level] + 1;
1588 lst = get_bits1(gb);
1589 if(v->s.esc3_level_length == 0) {
1590 if(v->pq < 8 || v->dquantfrm) { // table 59
1591 v->s.esc3_level_length = get_bits(gb, 3);
1592 if(!v->s.esc3_level_length)
1593 v->s.esc3_level_length = get_bits(gb, 2) + 8;
1595 v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
1597 v->s.esc3_run_length = 3 + get_bits(gb, 2);
1599 run = get_bits(gb, v->s.esc3_run_length);
1600 sign = get_bits1(gb);
1601 level = get_bits(gb, v->s.esc3_level_length);
1612 /** Decode intra block in intra frames - should be faster than decode_intra_block
1613 * @param v VC1Context
1614 * @param block block to decode
1615 * @param[in] n subblock index
1616 * @param coded are AC coeffs present or not
1617 * @param codingset set of VLC to decode data
1619 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
1621 GetBitContext *gb = &v->s.gb;
1622 MpegEncContext *s = &v->s;
1623 int dc_pred_dir = 0; /* Direction of the DC prediction used */
1626 int16_t *ac_val, *ac_val2;
1629 /* Get DC differential */
1631 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1633 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1636 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1641 if (dcdiff == 119 /* ESC index value */)
1643 /* TODO: Optimize */
1644 if (v->pq == 1) dcdiff = get_bits(gb, 10);
1645 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
1646 else dcdiff = get_bits(gb, 8);
1651 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1652 else if (v->pq == 2)
1653 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
1660 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
1663 /* Store the quantized DC coeff, used for prediction */
1665 block[0] = dcdiff * s->y_dc_scale;
1667 block[0] = dcdiff * s->c_dc_scale;
1678 int last = 0, skip, value;
1679 const uint8_t *zz_table;
1683 scale = v->pq * 2 + v->halfpq;
1687 zz_table = v->zz_8x8[2];
1689 zz_table = v->zz_8x8[3];
1691 zz_table = v->zz_8x8[1];
1693 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1695 if(dc_pred_dir) //left
1698 ac_val -= 16 * s->block_wrap[n];
1701 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
1705 block[zz_table[i++]] = value;
1708 /* apply AC prediction if needed */
1710 if(dc_pred_dir) { //left
1711 for(k = 1; k < 8; k++)
1712 block[k << v->left_blk_sh] += ac_val[k];
1714 for(k = 1; k < 8; k++)
1715 block[k << v->top_blk_sh] += ac_val[k + 8];
1718 /* save AC coeffs for further prediction */
1719 for(k = 1; k < 8; k++) {
1720 ac_val2[k] = block[k << v->left_blk_sh];
1721 ac_val2[k + 8] = block[k << v->top_blk_sh];
1724 /* scale AC coeffs */
1725 for(k = 1; k < 64; k++)
1729 block[k] += (block[k] < 0) ? -v->pq : v->pq;
1732 if(s->ac_pred) i = 63;
1738 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1742 scale = v->pq * 2 + v->halfpq;
1743 memset(ac_val2, 0, 16 * 2);
1744 if(dc_pred_dir) {//left
1747 memcpy(ac_val2, ac_val, 8 * 2);
1749 ac_val -= 16 * s->block_wrap[n];
1751 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
1754 /* apply AC prediction if needed */
1756 if(dc_pred_dir) { //left
1757 for(k = 1; k < 8; k++) {
1758 block[k << v->left_blk_sh] = ac_val[k] * scale;
1759 if(!v->pquantizer && block[k << v->left_blk_sh])
1760 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
1763 for(k = 1; k < 8; k++) {
1764 block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
1765 if(!v->pquantizer && block[k << v->top_blk_sh])
1766 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
1772 s->block_last_index[n] = i;
1777 /** Decode intra block in intra frames - should be faster than decode_intra_block
1778 * @param v VC1Context
1779 * @param block block to decode
1780 * @param[in] n subblock number
1781 * @param coded are AC coeffs present or not
1782 * @param codingset set of VLC to decode data
1783 * @param mquant quantizer value for this macroblock
1785 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
1787 GetBitContext *gb = &v->s.gb;
1788 MpegEncContext *s = &v->s;
1789 int dc_pred_dir = 0; /* Direction of the DC prediction used */
1792 int16_t *ac_val, *ac_val2;
1794 int a_avail = v->a_avail, c_avail = v->c_avail;
1795 int use_pred = s->ac_pred;
1798 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1800 /* Get DC differential */
1802 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1804 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1807 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1812 if (dcdiff == 119 /* ESC index value */)
1814 /* TODO: Optimize */
1815 if (mquant == 1) dcdiff = get_bits(gb, 10);
1816 else if (mquant == 2) dcdiff = get_bits(gb, 9);
1817 else dcdiff = get_bits(gb, 8);
1822 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1823 else if (mquant == 2)
1824 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
1831 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
1834 /* Store the quantized DC coeff, used for prediction */
1836 block[0] = dcdiff * s->y_dc_scale;
1838 block[0] = dcdiff * s->c_dc_scale;
1844 /* check if AC is needed at all */
1845 if(!a_avail && !c_avail) use_pred = 0;
1846 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1849 scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
1851 if(dc_pred_dir) //left
1854 ac_val -= 16 * s->block_wrap[n];
1856 q1 = s->current_picture.f.qscale_table[mb_pos];
1857 if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.f.qscale_table[mb_pos - 1];
1858 if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
1859 if(dc_pred_dir && n==1) q2 = q1;
1860 if(!dc_pred_dir && n==2) q2 = q1;
1864 int last = 0, skip, value;
1865 const uint8_t *zz_table;
1870 zz_table = v->zz_8x8[2];
1872 zz_table = v->zz_8x8[3];
1874 zz_table = v->zz_8x8[1];
1877 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
1881 block[zz_table[i++]] = value;
1884 /* apply AC prediction if needed */
1886 /* scale predictors if needed*/
1888 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
1889 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
1891 if(dc_pred_dir) { //left
1892 for(k = 1; k < 8; k++)
1893 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1895 for(k = 1; k < 8; k++)
1896 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1899 if(dc_pred_dir) { //left
1900 for(k = 1; k < 8; k++)
1901 block[k << v->left_blk_sh] += ac_val[k];
1903 for(k = 1; k < 8; k++)
1904 block[k << v->top_blk_sh] += ac_val[k + 8];
1908 /* save AC coeffs for further prediction */
1909 for(k = 1; k < 8; k++) {
1910 ac_val2[k ] = block[k << v->left_blk_sh];
1911 ac_val2[k + 8] = block[k << v->top_blk_sh];
1914 /* scale AC coeffs */
1915 for(k = 1; k < 64; k++)
1919 block[k] += (block[k] < 0) ? -mquant : mquant;
1922 if(use_pred) i = 63;
1923 } else { // no AC coeffs
1926 memset(ac_val2, 0, 16 * 2);
1927 if(dc_pred_dir) {//left
1929 memcpy(ac_val2, ac_val, 8 * 2);
1931 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
1932 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
1933 for(k = 1; k < 8; k++)
1934 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1939 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
1941 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
1942 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
1943 for(k = 1; k < 8; k++)
1944 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1949 /* apply AC prediction if needed */
1951 if(dc_pred_dir) { //left
1952 for(k = 1; k < 8; k++) {
1953 block[k << v->left_blk_sh] = ac_val2[k] * scale;
1954 if(!v->pquantizer && block[k << v->left_blk_sh])
1955 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
1958 for(k = 1; k < 8; k++) {
1959 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
1960 if(!v->pquantizer && block[k << v->top_blk_sh])
1961 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
1967 s->block_last_index[n] = i;
1972 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
1973 * @param v VC1Context
1974 * @param block block to decode
1975 * @param[in] n subblock index
1976 * @param coded are AC coeffs present or not
1977 * @param mquant block quantizer
1978 * @param codingset set of VLC to decode data
1980 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
1982 GetBitContext *gb = &v->s.gb;
1983 MpegEncContext *s = &v->s;
1984 int dc_pred_dir = 0; /* Direction of the DC prediction used */
1987 int16_t *ac_val, *ac_val2;
1989 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1990 int a_avail = v->a_avail, c_avail = v->c_avail;
1991 int use_pred = s->ac_pred;
1995 s->dsp.clear_block(block);
1997 /* XXX: Guard against dumb values of mquant */
1998 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
2000 /* Set DC scale - y and c use the same */
2001 s->y_dc_scale = s->y_dc_scale_table[mquant];
2002 s->c_dc_scale = s->c_dc_scale_table[mquant];
2004 /* Get DC differential */
2006 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2008 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2011 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2016 if (dcdiff == 119 /* ESC index value */)
2018 /* TODO: Optimize */
2019 if (mquant == 1) dcdiff = get_bits(gb, 10);
2020 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2021 else dcdiff = get_bits(gb, 8);
2026 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2027 else if (mquant == 2)
2028 dcdiff = (dcdiff<<1) + get_bits1(gb) - 1;
2035 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2038 /* Store the quantized DC coeff, used for prediction */
2041 block[0] = dcdiff * s->y_dc_scale;
2043 block[0] = dcdiff * s->c_dc_scale;
2049 /* check if AC is needed at all and adjust direction if needed */
2050 if(!a_avail) dc_pred_dir = 1;
2051 if(!c_avail) dc_pred_dir = 0;
2052 if(!a_avail && !c_avail) use_pred = 0;
2053 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2056 scale = mquant * 2 + v->halfpq;
2058 if(dc_pred_dir) //left
2061 ac_val -= 16 * s->block_wrap[n];
2063 q1 = s->current_picture.f.qscale_table[mb_pos];
2064 if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2065 if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2066 if(dc_pred_dir && n==1) q2 = q1;
2067 if(!dc_pred_dir && n==2) q2 = q1;
2071 int last = 0, skip, value;
2075 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2079 block[v->zz_8x8[0][i++]] = value;
2082 /* apply AC prediction if needed */
2084 /* scale predictors if needed*/
2086 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2087 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2089 if(dc_pred_dir) { //left
2090 for(k = 1; k < 8; k++)
2091 block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2093 for(k = 1; k < 8; k++)
2094 block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2097 if(dc_pred_dir) { //left
2098 for(k = 1; k < 8; k++)
2099 block[k << v->left_blk_sh] += ac_val[k];
2101 for(k = 1; k < 8; k++)
2102 block[k << v->top_blk_sh] += ac_val[k + 8];
2106 /* save AC coeffs for further prediction */
2107 for(k = 1; k < 8; k++) {
2108 ac_val2[k ] = block[k << v->left_blk_sh];
2109 ac_val2[k + 8] = block[k << v->top_blk_sh];
2112 /* scale AC coeffs */
2113 for(k = 1; k < 64; k++)
2117 block[k] += (block[k] < 0) ? -mquant : mquant;
2120 if(use_pred) i = 63;
2121 } else { // no AC coeffs
2124 memset(ac_val2, 0, 16 * 2);
2125 if(dc_pred_dir) {//left
2127 memcpy(ac_val2, ac_val, 8 * 2);
2129 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2130 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2131 for(k = 1; k < 8; k++)
2132 ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2137 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2139 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2140 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2141 for(k = 1; k < 8; k++)
2142 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2147 /* apply AC prediction if needed */
2149 if(dc_pred_dir) { //left
2150 for(k = 1; k < 8; k++) {
2151 block[k << v->left_blk_sh] = ac_val2[k] * scale;
2152 if(!v->pquantizer && block[k << v->left_blk_sh])
2153 block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2156 for(k = 1; k < 8; k++) {
2157 block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2158 if(!v->pquantizer && block[k << v->top_blk_sh])
2159 block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2165 s->block_last_index[n] = i;
2172 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block,
2173 uint8_t *dst, int linesize, int skip_block, int *ttmb_out)
2175 MpegEncContext *s = &v->s;
2176 GetBitContext *gb = &s->gb;
2179 int scale, off, idx, last, skip, value;
2180 int ttblk = ttmb & 7;
2183 s->dsp.clear_block(block);
2186 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)];
2188 if(ttblk == TT_4X4) {
2189 subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
2191 if((ttblk != TT_8X8 && ttblk != TT_4X4)
2192 && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
2193 || (!v->res_rtm_flag && !first_block))) {
2194 subblkpat = decode012(gb);
2195 if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
2196 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
2197 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
2199 scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
2201 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2202 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
2203 subblkpat = 2 - (ttblk == TT_8X4_TOP);
2206 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
2207 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
2216 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2220 idx = v->zz_8x8[0][i++];
2221 block[idx] = value * scale;
2223 block[idx] += (block[idx] < 0) ? -mquant : mquant;
2227 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
2229 v->vc1dsp.vc1_inv_trans_8x8(block);
2230 s->dsp.add_pixels_clamped(block, dst, linesize);
2235 pat = ~subblkpat & 0xF;
2236 for(j = 0; j < 4; j++) {
2237 last = subblkpat & (1 << (3 - j));
2239 off = (j & 1) * 4 + (j & 2) * 16;
2241 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2245 idx = ff_vc1_simple_progressive_4x4_zz[i++];
2246 block[idx + off] = value * scale;
2248 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2250 if(!(subblkpat & (1 << (3 - j))) && !skip_block){
2252 v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off);
2254 v->vc1dsp.vc1_inv_trans_4x4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off);
2259 pat = ~((subblkpat & 2)*6 + (subblkpat & 1)*3) & 0xF;
2260 for(j = 0; j < 2; j++) {
2261 last = subblkpat & (1 << (1 - j));
2265 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2269 idx = v->zz_8x4[i++]+off;
2270 block[idx] = value * scale;
2272 block[idx] += (block[idx] < 0) ? -mquant : mquant;
2274 if(!(subblkpat & (1 << (1 - j))) && !skip_block){
2276 v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j*4*linesize, linesize, block + off);
2278 v->vc1dsp.vc1_inv_trans_8x4(dst + j*4*linesize, linesize, block + off);
2283 pat = ~(subblkpat*5) & 0xF;
2284 for(j = 0; j < 2; j++) {
2285 last = subblkpat & (1 << (1 - j));
2289 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2293 idx = v->zz_4x8[i++]+off;
2294 block[idx] = value * scale;
2296 block[idx] += (block[idx] < 0) ? -mquant : mquant;
2298 if(!(subblkpat & (1 << (1 - j))) && !skip_block){
2300 v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j*4, linesize, block + off);
2302 v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
2308 *ttmb_out |= ttblk << (n * 4);
2312 /** @} */ // Macroblock group
2314 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
2315 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2317 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
2319 MpegEncContext *s = &v->s;
2320 int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
2321 block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
2322 mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
2323 block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
2324 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
2328 dst = s->dest[block_num - 3];
2330 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
2332 if (s->mb_y != s->mb_height || block_num < 2) {
2337 bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
2338 bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
2339 mv = &v->luma_mv[s->mb_x - s->mb_stride];
2340 mv_stride = s->mb_stride;
2342 bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4)) :
2343 (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
2344 bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4)) :
2345 (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
2346 mv_stride = s->b8_stride;
2347 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
2350 if (bottom_is_intra & 1 || block_is_intra & 1 ||
2351 mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
2352 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
2354 idx = ((bottom_cbp >> 2) | block_cbp) & 3;
2356 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
2359 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
2361 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
2366 dst -= 4 * linesize;
2367 ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xf;
2368 if (ttblk == TT_4X4 || ttblk == TT_8X4) {
2369 idx = (block_cbp | (block_cbp >> 2)) & 3;
2371 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
2374 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
2376 v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
2381 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
2383 MpegEncContext *s = &v->s;
2384 int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
2385 block_cbp = mb_cbp >> (block_num * 4), right_cbp,
2386 mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
2387 block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
2388 int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
2391 if (block_num > 3) {
2392 dst = s->dest[block_num - 3] - 8 * linesize;
2394 dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
2397 if (s->mb_x != s->mb_width || !(block_num & 5)) {
2401 right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
2402 right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
2403 mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
2405 right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4)) :
2406 (mb_cbp >> ((block_num + 1) * 4));
2407 right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4)) :
2408 (mb_is_intra >> ((block_num + 1) * 4));
2409 mv = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
2411 if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
2412 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
2414 idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
2416 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
2419 v->vc1dsp.vc1_h_loop_filter4(dst+4*linesize, linesize, v->pq);
2421 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
2427 ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
2428 if (ttblk == TT_4X4 || ttblk == TT_4X8) {
2429 idx = (block_cbp | (block_cbp >> 1)) & 5;
2431 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
2434 v->vc1dsp.vc1_h_loop_filter4(dst + linesize*4, linesize, v->pq);
2436 v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
2441 static void vc1_apply_p_loop_filter(VC1Context *v)
2443 MpegEncContext *s = &v->s;
2446 for (i = 0; i < 6; i++) {
2447 vc1_apply_p_v_loop_filter(v, i);
2450 /* V always preceedes H, therefore we run H one MB before V;
2451 * at the end of a row, we catch up to complete the row */
2453 for (i = 0; i < 6; i++) {
2454 vc1_apply_p_h_loop_filter(v, i);
2456 if (s->mb_x == s->mb_width - 1) {
2458 ff_update_block_index(s);
2459 for (i = 0; i < 6; i++) {
2460 vc1_apply_p_h_loop_filter(v, i);
2466 /** Decode one P-frame MB (in Simple/Main profile)
2468 static int vc1_decode_p_mb(VC1Context *v)
2470 MpegEncContext *s = &v->s;
2471 GetBitContext *gb = &s->gb;
2473 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2474 int cbp; /* cbp decoding stuff */
2475 int mqdiff, mquant; /* MB quantization */
2476 int ttmb = v->ttfrm; /* MB Transform type */
2478 int mb_has_coeffs = 1; /* last_flag */
2479 int dmv_x, dmv_y; /* Differential MV components */
2480 int index, index1; /* LUT indexes */
2481 int val, sign; /* temp values */
2482 int first_block = 1;
2484 int skipped, fourmv;
2485 int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
2487 mquant = v->pq; /* Loosy initialization */
2489 if (v->mv_type_is_raw)
2490 fourmv = get_bits1(gb);
2492 fourmv = v->mv_type_mb_plane[mb_pos];
2494 skipped = get_bits1(gb);
2496 skipped = v->s.mbskip_table[mb_pos];
2498 if (!fourmv) /* 1MV mode */
2502 GET_MVDATA(dmv_x, dmv_y);
2505 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
2506 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
2508 s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
2509 vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
2511 /* FIXME Set DC val for inter block ? */
2512 if (s->mb_intra && !mb_has_coeffs)
2515 s->ac_pred = get_bits1(gb);
2518 else if (mb_has_coeffs)
2520 if (s->mb_intra) s->ac_pred = get_bits1(gb);
2521 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2529 s->current_picture.f.qscale_table[mb_pos] = mquant;
2531 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2532 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
2533 VC1_TTMB_VLC_BITS, 2);
2534 if(!s->mb_intra) vc1_mc_1mv(v, 0);
2538 s->dc_val[0][s->block_index[i]] = 0;
2540 val = ((cbp >> (5 - i)) & 1);
2541 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2542 v->mb_type[0][s->block_index[i]] = s->mb_intra;
2544 /* check if prediction blocks A and C are available */
2545 v->a_avail = v->c_avail = 0;
2546 if(i == 2 || i == 3 || !s->first_slice_line)
2547 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2548 if(i == 1 || i == 3 || s->mb_x)
2549 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2551 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2552 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
2553 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
2554 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
2555 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
2556 if(v->pq >= 9 && v->overlap) {
2558 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
2560 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
2562 block_cbp |= 0xF << (i << 2);
2563 block_intra |= 1 << i;
2565 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
2566 block_cbp |= pat << (i << 2);
2567 if(!v->ttmbf && ttmb < 8) ttmb = -1;
2575 for(i = 0; i < 6; i++) {
2576 v->mb_type[0][s->block_index[i]] = 0;
2577 s->dc_val[0][s->block_index[i]] = 0;
2579 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_SKIP;
2580 s->current_picture.f.qscale_table[mb_pos] = 0;
2581 vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
2587 if (!skipped /* unskipped MB */)
2589 int intra_count = 0, coded_inter = 0;
2590 int is_intra[6], is_coded[6];
2592 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2595 val = ((cbp >> (5 - i)) & 1);
2596 s->dc_val[0][s->block_index[i]] = 0;
2603 GET_MVDATA(dmv_x, dmv_y);
2605 vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
2606 if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
2607 intra_count += s->mb_intra;
2608 is_intra[i] = s->mb_intra;
2609 is_coded[i] = mb_has_coeffs;
2612 is_intra[i] = (intra_count >= 3);
2615 if(i == 4) vc1_mc_4mv_chroma(v);
2616 v->mb_type[0][s->block_index[i]] = is_intra[i];
2617 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
2619 // if there are no coded blocks then don't do anything more
2621 if(!intra_count && !coded_inter)
2624 s->current_picture.f.qscale_table[mb_pos] = mquant;
2625 /* test if block is intra and has pred */
2630 if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
2631 || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
2636 if(intrapred)s->ac_pred = get_bits1(gb);
2637 else s->ac_pred = 0;
2639 if (!v->ttmbf && coded_inter)
2640 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
2644 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2645 s->mb_intra = is_intra[i];
2647 /* check if prediction blocks A and C are available */
2648 v->a_avail = v->c_avail = 0;
2649 if(i == 2 || i == 3 || !s->first_slice_line)
2650 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2651 if(i == 1 || i == 3 || s->mb_x)
2652 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2654 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
2655 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
2656 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
2657 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
2658 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2659 if(v->pq >= 9 && v->overlap) {
2661 v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
2663 v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
2665 block_cbp |= 0xF << (i << 2);
2666 block_intra |= 1 << i;
2667 } else if(is_coded[i]) {
2668 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
2669 block_cbp |= pat << (i << 2);
2670 if(!v->ttmbf && ttmb < 8) ttmb = -1;
2678 s->current_picture.f.qscale_table[mb_pos] = 0;
2679 for (i=0; i<6; i++) {
2680 v->mb_type[0][s->block_index[i]] = 0;
2681 s->dc_val[0][s->block_index[i]] = 0;
2685 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
2686 vc1_mc_4mv_luma(v, i);
2688 vc1_mc_4mv_chroma(v);
2689 s->current_picture.f.qscale_table[mb_pos] = 0;
2693 v->cbp[s->mb_x] = block_cbp;
2694 v->ttblk[s->mb_x] = block_tt;
2695 v->is_intra[s->mb_x] = block_intra;
2700 /** Decode one B-frame MB (in Main profile)
2702 static void vc1_decode_b_mb(VC1Context *v)
2704 MpegEncContext *s = &v->s;
2705 GetBitContext *gb = &s->gb;
2707 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2708 int cbp = 0; /* cbp decoding stuff */
2709 int mqdiff, mquant; /* MB quantization */
2710 int ttmb = v->ttfrm; /* MB Transform type */
2711 int mb_has_coeffs = 0; /* last_flag */
2712 int index, index1; /* LUT indexes */
2713 int val, sign; /* temp values */
2714 int first_block = 1;
2716 int skipped, direct;
2717 int dmv_x[2], dmv_y[2];
2718 int bmvtype = BMV_TYPE_BACKWARD;
2720 mquant = v->pq; /* Loosy initialization */
2724 direct = get_bits1(gb);
2726 direct = v->direct_mb_plane[mb_pos];
2728 skipped = get_bits1(gb);
2730 skipped = v->s.mbskip_table[mb_pos];
2732 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
2733 for(i = 0; i < 6; i++) {
2734 v->mb_type[0][s->block_index[i]] = 0;
2735 s->dc_val[0][s->block_index[i]] = 0;
2737 s->current_picture.f.qscale_table[mb_pos] = 0;
2741 GET_MVDATA(dmv_x[0], dmv_y[0]);
2742 dmv_x[1] = dmv_x[0];
2743 dmv_y[1] = dmv_y[0];
2745 if(skipped || !s->mb_intra) {
2746 bmvtype = decode012(gb);
2749 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
2752 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
2755 bmvtype = BMV_TYPE_INTERPOLATED;
2756 dmv_x[0] = dmv_y[0] = 0;
2760 for(i = 0; i < 6; i++)
2761 v->mb_type[0][s->block_index[i]] = s->mb_intra;
2764 if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
2765 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
2766 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
2770 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2773 s->current_picture.f.qscale_table[mb_pos] = mquant;
2775 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
2776 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
2777 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
2778 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
2780 if(!mb_has_coeffs && !s->mb_intra) {
2781 /* no coded blocks - effectively skipped */
2782 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
2783 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
2786 if(s->mb_intra && !mb_has_coeffs) {
2788 s->current_picture.f.qscale_table[mb_pos] = mquant;
2789 s->ac_pred = get_bits1(gb);
2791 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
2793 if(bmvtype == BMV_TYPE_INTERPOLATED) {
2794 GET_MVDATA(dmv_x[0], dmv_y[0]);
2795 if(!mb_has_coeffs) {
2796 /* interpolated skipped block */
2797 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
2798 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
2802 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
2804 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
2807 s->ac_pred = get_bits1(gb);
2808 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2810 s->current_picture.f.qscale_table[mb_pos] = mquant;
2811 if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2812 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
2818 s->dc_val[0][s->block_index[i]] = 0;
2820 val = ((cbp >> (5 - i)) & 1);
2821 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2822 v->mb_type[0][s->block_index[i]] = s->mb_intra;
2824 /* check if prediction blocks A and C are available */
2825 v->a_avail = v->c_avail = 0;
2826 if(i == 2 || i == 3 || !s->first_slice_line)
2827 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2828 if(i == 1 || i == 3 || s->mb_x)
2829 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2831 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2832 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
2833 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
2834 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
2835 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
2837 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), NULL);
2838 if(!v->ttmbf && ttmb < 8) ttmb = -1;
2844 /** Decode blocks of I-frame
2846 static void vc1_decode_i_blocks(VC1Context *v)
2849 MpegEncContext *s = &v->s;
2854 /* select codingmode used for VLC tables selection */
2855 switch(v->y_ac_table_index){
2857 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2860 v->codingset = CS_HIGH_MOT_INTRA;
2863 v->codingset = CS_MID_RATE_INTRA;
2867 switch(v->c_ac_table_index){
2869 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2872 v->codingset2 = CS_HIGH_MOT_INTER;
2875 v->codingset2 = CS_MID_RATE_INTER;
2879 /* Set DC scale - y and c use the same */
2880 s->y_dc_scale = s->y_dc_scale_table[v->pq];
2881 s->c_dc_scale = s->c_dc_scale_table[v->pq];
2884 s->mb_x = s->mb_y = 0;
2886 s->first_slice_line = 1;
2887 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2889 ff_init_block_index(s);
2890 for(; s->mb_x < s->mb_width; s->mb_x++) {
2892 ff_update_block_index(s);
2893 dst[0] = s->dest[0];
2894 dst[1] = dst[0] + 8;
2895 dst[2] = s->dest[0] + s->linesize * 8;
2896 dst[3] = dst[2] + 8;
2897 dst[4] = s->dest[1];
2898 dst[5] = s->dest[2];
2899 s->dsp.clear_blocks(s->block[0]);
2900 mb_pos = s->mb_x + s->mb_y * s->mb_width;
2901 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
2902 s->current_picture.f.qscale_table[mb_pos] = v->pq;
2903 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
2904 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
2906 // do actual MB decoding and displaying
2907 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2908 v->s.ac_pred = get_bits1(&v->s.gb);
2910 for(k = 0; k < 6; k++) {
2911 val = ((cbp >> (5 - k)) & 1);
2914 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2918 cbp |= val << (5 - k);
2920 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
2922 if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue;
2923 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
2924 if(v->pq >= 9 && v->overlap) {
2925 if (v->rangeredfrm) for(j = 0; j < 64; j++) s->block[k][j] <<= 1;
2926 s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
2928 if (v->rangeredfrm) for(j = 0; j < 64; j++) s->block[k][j] = (s->block[k][j] - 64) << 1;
2929 s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
2933 if(v->pq >= 9 && v->overlap) {
2935 v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
2936 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2937 if(!(s->flags & CODEC_FLAG_GRAY)) {
2938 v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
2939 v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
2942 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
2943 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2944 if(!s->first_slice_line) {
2945 v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
2946 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
2947 if(!(s->flags & CODEC_FLAG_GRAY)) {
2948 v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
2949 v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
2952 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2953 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2955 if(v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
2957 if(get_bits_count(&s->gb) > v->bits) {
2958 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
2959 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
2963 if (!v->s.loop_filter)
2964 ff_draw_horiz_band(s, s->mb_y * 16, 16);
2966 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
2968 s->first_slice_line = 0;
2970 if (v->s.loop_filter)
2971 ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
2972 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2975 /** Decode blocks of I-frame for advanced profile
2977 static void vc1_decode_i_blocks_adv(VC1Context *v)
2980 MpegEncContext *s = &v->s;
2986 GetBitContext *gb = &s->gb;
2988 /* select codingmode used for VLC tables selection */
2989 switch(v->y_ac_table_index){
2991 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2994 v->codingset = CS_HIGH_MOT_INTRA;
2997 v->codingset = CS_MID_RATE_INTRA;
3001 switch(v->c_ac_table_index){
3003 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3006 v->codingset2 = CS_HIGH_MOT_INTER;
3009 v->codingset2 = CS_MID_RATE_INTER;
3014 s->mb_x = s->mb_y = 0;
3016 s->first_slice_line = 1;
3017 s->mb_y = s->start_mb_y;
3018 if (s->start_mb_y) {
3020 ff_init_block_index(s);
3021 memset(&s->coded_block[s->block_index[0]-s->b8_stride], 0,
3022 (1 + s->b8_stride) * sizeof(*s->coded_block));
3024 for(; s->mb_y < s->end_mb_y; s->mb_y++) {
3026 ff_init_block_index(s);
3027 for(;s->mb_x < s->mb_width; s->mb_x++) {
3028 DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
3029 ff_update_block_index(s);
3030 s->dsp.clear_blocks(block[0]);
3031 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3032 s->current_picture.f.mb_type[mb_pos] = MB_TYPE_INTRA;
3033 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3034 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3036 // do actual MB decoding and displaying
3037 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3038 if(v->acpred_is_raw)
3039 v->s.ac_pred = get_bits1(&v->s.gb);
3041 v->s.ac_pred = v->acpred_plane[mb_pos];
3043 if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
3044 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
3048 s->current_picture.f.qscale_table[mb_pos] = mquant;
3049 /* Set DC scale - y and c use the same */
3050 s->y_dc_scale = s->y_dc_scale_table[mquant];
3051 s->c_dc_scale = s->c_dc_scale_table[mquant];
3053 for(k = 0; k < 6; k++) {
3054 val = ((cbp >> (5 - k)) & 1);
3057 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3061 cbp |= val << (5 - k);
3063 v->a_avail = !s->first_slice_line || (k==2 || k==3);
3064 v->c_avail = !!s->mb_x || (k==1 || k==3);
3066 vc1_decode_i_block_adv(v, block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
3068 if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue;
3069 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
3072 vc1_smooth_overlap_filter_iblk(v);
3073 vc1_put_signed_blocks_clamped(v);
3074 if(v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
3076 if(get_bits_count(&s->gb) > v->bits) {
3077 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
3078 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3082 if (!v->s.loop_filter)
3083 ff_draw_horiz_band(s, s->mb_y * 16, 16);
3085 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
3086 s->first_slice_line = 0;
3089 /* raw bottom MB row */
3091 ff_init_block_index(s);
3092 for(;s->mb_x < s->mb_width; s->mb_x++) {
3093 ff_update_block_index(s);
3094 vc1_put_signed_blocks_clamped(v);
3095 if(v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
3097 if (v->s.loop_filter)
3098 ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
3099 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));
3102 static void vc1_decode_p_blocks(VC1Context *v)
3104 MpegEncContext *s = &v->s;
3105 int apply_loop_filter;
3107 /* select codingmode used for VLC tables selection */
3108 switch(v->c_ac_table_index){
3110 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3113 v->codingset = CS_HIGH_MOT_INTRA;
3116 v->codingset = CS_MID_RATE_INTRA;
3120 switch(v->c_ac_table_index){
3122 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3125 v->codingset2 = CS_HIGH_MOT_INTER;
3128 v->codingset2 = CS_MID_RATE_INTER;
3132 apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
3133 s->first_slice_line = 1;
3134 memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
3135 for(s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
3137 ff_init_block_index(s);
3138 for(; s->mb_x < s->mb_width; s->mb_x++) {
3139 ff_update_block_index(s);
3142 if (s->mb_y != s->start_mb_y && apply_loop_filter)
3143 vc1_apply_p_loop_filter(v);
3144 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
3145 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
3146 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
3150 memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0])*s->mb_stride);
3151 memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0])*s->mb_stride);
3152 memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3153 memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0])*s->mb_stride);
3154 if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
3155 s->first_slice_line = 0;
3157 if (apply_loop_filter) {
3159 ff_init_block_index(s);
3160 for (; s->mb_x < s->mb_width; s->mb_x++) {
3161 ff_update_block_index(s);
3162 vc1_apply_p_loop_filter(v);
3165 if (s->end_mb_y >= s->start_mb_y)
3166 ff_draw_horiz_band(s, (s->end_mb_y-1) * 16, 16);
3167 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));
3170 static void vc1_decode_b_blocks(VC1Context *v)
3172 MpegEncContext *s = &v->s;
3174 /* select codingmode used for VLC tables selection */
3175 switch(v->c_ac_table_index){
3177 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3180 v->codingset = CS_HIGH_MOT_INTRA;
3183 v->codingset = CS_MID_RATE_INTRA;
3187 switch(v->c_ac_table_index){
3189 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3192 v->codingset2 = CS_HIGH_MOT_INTER;
3195 v->codingset2 = CS_MID_RATE_INTER;
3199 s->first_slice_line = 1;
3200 for(s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
3202 ff_init_block_index(s);
3203 for(; s->mb_x < s->mb_width; s->mb_x++) {
3204 ff_update_block_index(s);
3207 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
3208 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
3209 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
3212 if(v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
3214 if (!v->s.loop_filter)
3215 ff_draw_horiz_band(s, s->mb_y * 16, 16);
3217 ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
3218 s->first_slice_line = 0;
3220 if (v->s.loop_filter)
3221 ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
3222 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));
3225 static void vc1_decode_skip_blocks(VC1Context *v)
3227 MpegEncContext *s = &v->s;
3229 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3230 s->first_slice_line = 1;
3231 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3233 ff_init_block_index(s);
3234 ff_update_block_index(s);
3235 memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
3236 memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
3237 memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
3238 ff_draw_horiz_band(s, s->mb_y * 16, 16);
3239 s->first_slice_line = 0;
3241 s->pict_type = AV_PICTURE_TYPE_P;
3244 static void vc1_decode_blocks(VC1Context *v)
3247 v->s.esc3_level_length = 0;
3249 ff_intrax8_decode_picture(&v->x8, 2*v->pq+v->halfpq, v->pq*(!v->pquantizer) );
3252 v->left_blk_idx = -1;
3253 v->topleft_blk_idx = 1;
3255 switch(v->s.pict_type) {
3256 case AV_PICTURE_TYPE_I:
3257 if(v->profile == PROFILE_ADVANCED)
3258 vc1_decode_i_blocks_adv(v);
3260 vc1_decode_i_blocks(v);
3262 case AV_PICTURE_TYPE_P:
3263 if(v->p_frame_skipped)
3264 vc1_decode_skip_blocks(v);
3266 vc1_decode_p_blocks(v);
3268 case AV_PICTURE_TYPE_B:
3270 if(v->profile == PROFILE_ADVANCED)
3271 vc1_decode_i_blocks_adv(v);
3273 vc1_decode_i_blocks(v);
3275 vc1_decode_b_blocks(v);
3281 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
3285 * Transform coefficients for both sprites in 16.16 fixed point format,
3286 * in the order they appear in the bitstream:
3288 * rotation 1 (unused)
3290 * rotation 2 (unused)
3297 int effect_type, effect_flag;
3298 int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
3299 int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
3302 static inline int get_fp_val(GetBitContext* gb)
3304 return (get_bits_long(gb, 30) - (1<<29)) << 1;
3307 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
3311 switch (get_bits(gb, 2)) {
3314 c[2] = get_fp_val(gb);
3318 c[0] = c[4] = get_fp_val(gb);
3319 c[2] = get_fp_val(gb);
3322 c[0] = get_fp_val(gb);
3323 c[2] = get_fp_val(gb);
3324 c[4] = get_fp_val(gb);
3327 c[0] = get_fp_val(gb);
3328 c[1] = get_fp_val(gb);
3329 c[2] = get_fp_val(gb);
3330 c[3] = get_fp_val(gb);
3331 c[4] = get_fp_val(gb);
3334 c[5] = get_fp_val(gb);
3336 c[6] = get_fp_val(gb);
3341 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
3343 AVCodecContext *avctx = v->s.avctx;
3346 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
3347 vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
3348 if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
3349 av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
3350 av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
3351 for (i = 0; i < 7; i++)
3352 av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
3353 sd->coefs[sprite][i] / (1<<16),
3354 (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1<<16));
3355 av_log(avctx, AV_LOG_DEBUG, "\n");
3359 if (sd->effect_type = get_bits_long(gb, 30)) {
3360 switch (sd->effect_pcount1 = get_bits(gb, 4)) {
3362 vc1_sprite_parse_transform(gb, sd->effect_params1);
3365 vc1_sprite_parse_transform(gb, sd->effect_params1);
3366 vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
3369 for (i = 0; i < sd->effect_pcount1; i++)
3370 sd->effect_params1[i] = get_fp_val(gb);
3372 if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
3373 // effect 13 is simple alpha blending and matches the opacity above
3374 av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
3375 for (i = 0; i < sd->effect_pcount1; i++)
3376 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
3377 sd->effect_params1[i] / (1<<16),
3378 (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1<<16));
3379 av_log(avctx, AV_LOG_DEBUG, "\n");
3382 sd->effect_pcount2 = get_bits(gb, 16);
3383 if (sd->effect_pcount2 > 10) {
3384 av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
3386 } else if (sd->effect_pcount2) {
3388 av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
3389 while (++i < sd->effect_pcount2){
3390 sd->effect_params2[i] = get_fp_val(gb);
3391 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
3392 sd->effect_params2[i] / (1<<16),
3393 (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1<<16));
3395 av_log(avctx, AV_LOG_DEBUG, "\n");
3398 if (sd->effect_flag = get_bits1(gb))
3399 av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
3401 if (get_bits_count(gb) >= gb->size_in_bits +
3402 (avctx->codec_id == CODEC_ID_WMV3IMAGE ? 64 : 0))
3403 av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
3404 if (get_bits_count(gb) < gb->size_in_bits - 8)
3405 av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
3408 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
3410 int i, plane, row, sprite;
3411 int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
3412 uint8_t* src_h[2][2];
3413 int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
3415 MpegEncContext *s = &v->s;
3417 for (i = 0; i < 2; i++) {
3418 xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
3419 xadv[i] = sd->coefs[i][0];
3420 if (xadv[i] != 1<<16 || (v->sprite_width<<16) - (v->output_width<<16) - xoff[i])
3421 xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
3423 yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
3424 yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height<<16) - yoff[i]) / v->output_height);
3426 alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
3428 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
3429 int width = v->output_width>>!!plane;
3431 for (row = 0; row < v->output_height>>!!plane; row++) {
3432 uint8_t *dst = v->sprite_output_frame.data[plane] +
3433 v->sprite_output_frame.linesize[plane] * row;
3435 for (sprite = 0; sprite <= v->two_sprites; sprite++) {
3436 uint8_t *iplane = s->current_picture.f.data[plane];
3437 int iline = s->current_picture.f.linesize[plane];
3438 int ycoord = yoff[sprite] + yadv[sprite]*row;
3439 int yline = ycoord>>16;
3440 ysub[sprite] = ycoord&0xFFFF;
3442 iplane = s->last_picture.f.data[plane];
3443 iline = s->last_picture.f.linesize[plane];
3445 if (!(xoff[sprite]&0xFFFF) && xadv[sprite] == 1<<16) {
3446 src_h[sprite][0] = iplane+(xoff[sprite]>>16)+ yline *iline;
3448 src_h[sprite][1] = iplane+(xoff[sprite]>>16)+(yline+1)*iline;
3450 if (sr_cache[sprite][0] != yline) {
3451 if (sr_cache[sprite][1] == yline) {
3452 FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
3453 FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
3455 v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane+yline*iline, xoff[sprite], xadv[sprite], width);
3456 sr_cache[sprite][0] = yline;
3459 if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
3460 v->vc1dsp.sprite_h(v->sr_rows[sprite][1], iplane+(yline+1)*iline, xoff[sprite], xadv[sprite], width);
3461 sr_cache[sprite][1] = yline + 1;
3463 src_h[sprite][0] = v->sr_rows[sprite][0];
3464 src_h[sprite][1] = v->sr_rows[sprite][1];
3468 if (!v->two_sprites) {
3470 v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
3472 memcpy(dst, src_h[0][0], width);
3475 if (ysub[0] && ysub[1]) {
3476 v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
3477 src_h[1][0], src_h[1][1], ysub[1], alpha, width);
3478 } else if (ysub[0]) {
3479 v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
3480 src_h[1][0], alpha, width);
3481 } else if (ysub[1]) {
3482 v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
3483 src_h[0][0], (1<<16)-1-alpha, width);
3485 v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
3491 for (i = 0; i < 2; i++) {
3501 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
3503 MpegEncContext *s = &v->s;
3504 AVCodecContext *avctx = s->avctx;
3507 vc1_parse_sprites(v, gb, &sd);
3509 if (!s->current_picture.f.data[0]) {
3510 av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
3514 if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
3515 av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
3519 if (v->sprite_output_frame.data[0])
3520 avctx->release_buffer(avctx, &v->sprite_output_frame);
3522 v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
3523 v->sprite_output_frame.reference = 0;
3524 if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
3525 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
3529 vc1_draw_sprites(v, &sd);
3534 static void vc1_sprite_flush(AVCodecContext *avctx)
3536 VC1Context *v = avctx->priv_data;
3537 MpegEncContext *s = &v->s;
3538 AVFrame *f = &s->current_picture.f;
3541 /* Windows Media Image codecs have a convergence interval of two keyframes.
3542 Since we can't enforce it, clear to black the missing sprite. This is
3543 wrong but it looks better than doing nothing. */
3546 for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
3547 for (i = 0; i < v->sprite_height>>!!plane; i++)
3548 memset(f->data[plane]+i*f->linesize[plane],
3549 plane ? 128 : 0, f->linesize[plane]);
3554 /** Initialize a VC1/WMV3 decoder
3555 * @todo TODO: Handle VC-1 IDUs (Transport level?)
3556 * @todo TODO: Decypher remaining bits in extra_data
3558 static av_cold int vc1_decode_init(AVCodecContext *avctx)
3560 VC1Context *v = avctx->priv_data;
3561 MpegEncContext *s = &v->s;
3563 int i, cur_width, cur_height;
3565 /* save the container output size for WMImage */
3566 v->output_width = avctx->width;
3567 v->output_height = avctx->height;
3569 if (!avctx->extradata_size || !avctx->extradata) return -1;
3570 if (!(avctx->flags & CODEC_FLAG_GRAY))
3571 avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
3573 avctx->pix_fmt = PIX_FMT_GRAY8;
3574 avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
3576 avctx->flags |= CODEC_FLAG_EMU_EDGE;
3577 v->s.flags |= CODEC_FLAG_EMU_EDGE;
3579 if(avctx->idct_algo==FF_IDCT_AUTO){
3580 avctx->idct_algo=FF_IDCT_WMV2;
3583 if(ff_msmpeg4_decode_init(avctx) < 0)
3585 if (vc1_init_common(v) < 0) return -1;
3586 ff_vc1dsp_init(&v->vc1dsp);
3588 cur_width = avctx->coded_width = avctx->width;
3589 cur_height = avctx->coded_height = avctx->height;
3590 if (avctx->codec_id == CODEC_ID_WMV3 || avctx->codec_id == CODEC_ID_WMV3IMAGE)
3594 // looks like WMV3 has a sequence header stored in the extradata
3595 // advanced sequence header may be before the first frame
3596 // the last byte of the extradata is a version number, 1 for the
3597 // samples we can decode
3599 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
3601 if (vc1_decode_sequence_header(avctx, v, &gb) < 0)
3604 count = avctx->extradata_size*8 - get_bits_count(&gb);
3607 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
3608 count, get_bits(&gb, count));
3612 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
3614 } else { // VC1/WVC1/WVP2
3615 const uint8_t *start = avctx->extradata;
3616 uint8_t *end = avctx->extradata + avctx->extradata_size;
3617 const uint8_t *next;
3618 int size, buf2_size;
3619 uint8_t *buf2 = NULL;
3620 int seq_initialized = 0, ep_initialized = 0;
3622 if(avctx->extradata_size < 16) {
3623 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
3627 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
3628 start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
3630 for(; next < end; start = next){
3631 next = find_next_marker(start + 4, end);
3632 size = next - start - 4;
3633 if(size <= 0) continue;
3634 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
3635 init_get_bits(&gb, buf2, buf2_size * 8);
3636 switch(AV_RB32(start)){
3637 case VC1_CODE_SEQHDR:
3638 if(vc1_decode_sequence_header(avctx, v, &gb) < 0){
3642 seq_initialized = 1;
3644 case VC1_CODE_ENTRYPOINT:
3645 if(vc1_decode_entry_point(avctx, v, &gb) < 0){
3654 if(!seq_initialized || !ep_initialized){
3655 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
3658 v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
3660 // Sequence header information may not have been parsed
3661 // yet when ff_msmpeg4_decode_init was called the fist time
3662 // above. If sequence information changes, we need to call
3664 if (cur_width != avctx->width ||
3665 cur_height != avctx->height) {
3667 if(ff_msmpeg4_decode_init(avctx) < 0)
3669 avctx->coded_width = avctx->width;
3670 avctx->coded_height = avctx->height;
3673 avctx->profile = v->profile;
3674 if (v->profile == PROFILE_ADVANCED)
3675 avctx->level = v->level;
3677 avctx->has_b_frames= !!(avctx->max_b_frames);
3678 s->low_delay = !avctx->has_b_frames;
3680 s->mb_width = (avctx->coded_width+15)>>4;
3681 s->mb_height = (avctx->coded_height+15)>>4;
3683 if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
3684 for (i = 0; i < 64; i++) {
3685 #define transpose(x) ((x>>3) | ((x&7)<<3))
3686 v->zz_8x8[0][i] = transpose(wmv1_scantable[0][i]);
3687 v->zz_8x8[1][i] = transpose(wmv1_scantable[1][i]);
3688 v->zz_8x8[2][i] = transpose(wmv1_scantable[2][i]);
3689 v->zz_8x8[3][i] = transpose(wmv1_scantable[3][i]);
3694 memcpy(v->zz_8x8, wmv1_scantable, 4*64);
3699 /* Allocate mb bitplanes */
3700 v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
3701 v->direct_mb_plane = av_malloc(s->mb_stride * s->mb_height);
3702 v->acpred_plane = av_malloc(s->mb_stride * s->mb_height);
3703 v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height);
3705 v->n_allocated_blks = s->mb_width + 2;
3706 v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
3707 v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
3708 v->cbp = v->cbp_base + s->mb_stride;
3709 v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
3710 v->ttblk = v->ttblk_base + s->mb_stride;
3711 v->is_intra_base = av_malloc(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
3712 v->is_intra = v->is_intra_base + s->mb_stride;
3713 v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
3714 v->luma_mv = v->luma_mv_base + s->mb_stride;
3716 /* allocate block type info in that way so it could be used with s->block_index[] */
3717 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
3718 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
3719 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
3720 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
3722 /* Init coded blocks info */
3723 if (v->profile == PROFILE_ADVANCED)
3725 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
3727 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
3731 ff_intrax8_common_init(&v->x8,s);
3733 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
3734 for (i = 0; i < 4; i++)
3735 if (!(v->sr_rows[i>>1][i%2] = av_malloc(v->output_width))) return -1;
3739 v->sprite_width = avctx->coded_width;
3740 v->sprite_height = avctx->coded_height;
3742 avctx->coded_width = avctx->width = v->output_width;
3743 avctx->coded_height = avctx->height = v->output_height;
3745 // prevent 16.16 overflows
3746 if (v->sprite_width > 1<<14 ||
3747 v->sprite_height > 1<<14 ||
3748 v->output_width > 1<<14 ||
3749 v->output_height > 1<<14) return -1;
3755 /** Decode a VC1/WMV3 frame
3756 * @todo TODO: Handle VC-1 IDUs (Transport level?)
3758 static int vc1_decode_frame(AVCodecContext *avctx,
3759 void *data, int *data_size,
3762 const uint8_t *buf = avpkt->data;
3763 int buf_size = avpkt->size, n_slices = 0, i;
3764 VC1Context *v = avctx->priv_data;
3765 MpegEncContext *s = &v->s;
3766 AVFrame *pict = data;
3767 uint8_t *buf2 = NULL;
3768 const uint8_t *buf_start = buf;
3775 /* no supplementary picture */
3776 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
3777 /* special case for last picture */
3778 if (s->low_delay==0 && s->next_picture_ptr) {
3779 *pict= *(AVFrame*)s->next_picture_ptr;
3780 s->next_picture_ptr= NULL;
3782 *data_size = sizeof(AVFrame);
3788 /* We need to set current_picture_ptr before reading the header,
3789 * otherwise we cannot store anything in there. */
3790 if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
3791 int i= ff_find_unused_picture(s, 0);
3792 s->current_picture_ptr= &s->picture[i];
3795 if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){
3796 if (v->profile < PROFILE_ADVANCED)
3797 avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
3799 avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
3802 //for advanced profile we may need to parse and unescape data
3803 if (avctx->codec_id == CODEC_ID_VC1 || avctx->codec_id == CODEC_ID_VC1IMAGE) {
3805 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
3807 if(IS_MARKER(AV_RB32(buf))){ /* frame starts with marker and needs to be parsed */
3808 const uint8_t *start, *end, *next;
3812 for(start = buf, end = buf + buf_size; next < end; start = next){
3813 next = find_next_marker(start + 4, end);
3814 size = next - start - 4;
3815 if(size <= 0) continue;
3816 switch(AV_RB32(start)){
3817 case VC1_CODE_FRAME:
3818 if (avctx->hwaccel ||
3819 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
3821 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
3823 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
3824 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
3825 init_get_bits(&s->gb, buf2, buf_size2*8);
3826 vc1_decode_entry_point(avctx, v, &s->gb);
3828 case VC1_CODE_SLICE: {
3830 slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
3831 if (!slices) goto err;
3832 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
3833 if (!slices[n_slices].buf) goto err;
3834 buf_size3 = vc1_unescape_buffer(start + 4, size,
3835 slices[n_slices].buf);
3836 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
3838 slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
3844 }else if(v->interlace && ((buf[0] & 0xC0) == 0xC0)){ /* WVC1 interlaced stores both fields divided by marker */
3845 const uint8_t *divider;
3847 divider = find_next_marker(buf, buf + buf_size);
3848 if((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD){
3849 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
3853 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
3855 if(!v->warn_interlaced++)
3856 av_log(v->s.avctx, AV_LOG_ERROR, "Interlaced WVC1 support is not implemented\n");
3859 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
3861 init_get_bits(&s->gb, buf2, buf_size2*8);
3863 init_get_bits(&s->gb, buf, buf_size*8);
3865 if (v->res_sprite) {
3866 v->new_sprite = !get_bits1(&s->gb);
3867 v->two_sprites = get_bits1(&s->gb);
3868 /* res_sprite means a Windows Media Image stream, CODEC_ID_*IMAGE means
3869 we're using the sprite compositor. These are intentionally kept separate
3870 so you can get the raw sprites by using the wmv3 decoder for WMVP or
3871 the vc1 one for WVP2 */
3872 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
3873 if (v->new_sprite) {
3874 // switch AVCodecContext parameters to those of the sprites
3875 avctx->width = avctx->coded_width = v->sprite_width;
3876 avctx->height = avctx->coded_height = v->sprite_height;
3883 // do parse frame header
3884 if(v->profile < PROFILE_ADVANCED) {
3885 if(vc1_parse_frame_header(v, &s->gb) == -1) {
3889 if(vc1_parse_frame_header_adv(v, &s->gb) == -1) {
3894 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
3895 && s->pict_type!=AV_PICTURE_TYPE_I) {
3896 av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
3900 // for skipping the frame
3901 s->current_picture.f.pict_type = s->pict_type;
3902 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
3904 /* skip B-frames if we don't have reference frames */
3905 if(s->last_picture_ptr==NULL && (s->pict_type==AV_PICTURE_TYPE_B || s->dropable)){
3908 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
3909 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
3910 || avctx->skip_frame >= AVDISCARD_ALL) {
3914 if(s->next_p_frame_damaged){
3915 if(s->pict_type==AV_PICTURE_TYPE_B)
3918 s->next_p_frame_damaged=0;
3921 if(MPV_frame_start(s, avctx) < 0) {
3925 s->me.qpel_put= s->dsp.put_qpel_pixels_tab;
3926 s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
3928 if ((CONFIG_VC1_VDPAU_DECODER)
3929 &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
3930 ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
3931 else if (avctx->hwaccel) {
3932 if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
3934 if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
3936 if (avctx->hwaccel->end_frame(avctx) < 0)
3939 ff_er_frame_start(s);
3941 v->bits = buf_size * 8;
3942 for (i = 0; i <= n_slices; i++) {
3943 if (i && get_bits1(&s->gb))
3944 vc1_parse_frame_header_adv(v, &s->gb);
3945 s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start);
3946 s->end_mb_y = (i == n_slices) ? s->mb_height : FFMIN(s->mb_height, slices[i].mby_start);
3947 vc1_decode_blocks(v);
3948 if (i != n_slices) s->gb = slices[i].gb;
3950 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
3951 // if(get_bits_count(&s->gb) > buf_size * 8)
3958 assert(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);
3959 assert(s->current_picture.f.pict_type == s->pict_type);
3961 if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
3963 avctx->width = avctx->coded_width = v->output_width;
3964 avctx->height = avctx->coded_height = v->output_height;
3965 if (avctx->skip_frame >= AVDISCARD_NONREF) goto end;
3966 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
3967 if (vc1_decode_sprites(v, &s->gb)) goto err;
3969 *pict = v->sprite_output_frame;
3970 *data_size = sizeof(AVFrame);
3973 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
3974 *pict= *(AVFrame*)s->current_picture_ptr;
3975 } else if (s->last_picture_ptr != NULL) {
3976 *pict= *(AVFrame*)s->last_picture_ptr;
3979 if(s->last_picture_ptr || s->low_delay){
3980 *data_size = sizeof(AVFrame);
3981 ff_print_debug_info(s, pict);
3988 for (i = 0; i < n_slices; i++)
3989 av_free(slices[i].buf);
3995 for (i = 0; i < n_slices; i++)
3996 av_free(slices[i].buf);
4002 /** Close a VC1/WMV3 decoder
4003 * @warning Initial try at using MpegEncContext stuff
4005 static av_cold int vc1_decode_end(AVCodecContext *avctx)
4007 VC1Context *v = avctx->priv_data;
4010 if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
4011 && v->sprite_output_frame.data[0])
4012 avctx->release_buffer(avctx, &v->sprite_output_frame);
4013 for (i = 0; i < 4; i++)
4014 av_freep(&v->sr_rows[i>>1][i%2]);
4015 av_freep(&v->hrd_rate);
4016 av_freep(&v->hrd_buffer);
4017 MPV_common_end(&v->s);
4018 av_freep(&v->mv_type_mb_plane);
4019 av_freep(&v->direct_mb_plane);
4020 av_freep(&v->acpred_plane);
4021 av_freep(&v->over_flags_plane);
4022 av_freep(&v->mb_type_base);
4023 av_freep(&v->block);
4024 av_freep(&v->cbp_base);
4025 av_freep(&v->ttblk_base);
4026 av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
4027 av_freep(&v->luma_mv_base);
4028 ff_intrax8_common_end(&v->x8);
4032 static const AVProfile profiles[] = {
4033 { FF_PROFILE_VC1_SIMPLE, "Simple" },
4034 { FF_PROFILE_VC1_MAIN, "Main" },
4035 { FF_PROFILE_VC1_COMPLEX, "Complex" },
4036 { FF_PROFILE_VC1_ADVANCED, "Advanced" },
4037 { FF_PROFILE_UNKNOWN },
4040 AVCodec ff_vc1_decoder = {
4042 .type = AVMEDIA_TYPE_VIDEO,
4044 .priv_data_size = sizeof(VC1Context),
4045 .init = vc1_decode_init,
4046 .close = vc1_decode_end,
4047 .decode = vc1_decode_frame,
4048 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
4049 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
4050 .pix_fmts = ff_hwaccel_pixfmt_list_420,
4051 .profiles = NULL_IF_CONFIG_SMALL(profiles)
4054 #if CONFIG_WMV3_DECODER
4055 AVCodec ff_wmv3_decoder = {
4057 .type = AVMEDIA_TYPE_VIDEO,
4058 .id = CODEC_ID_WMV3,
4059 .priv_data_size = sizeof(VC1Context),
4060 .init = vc1_decode_init,
4061 .close = vc1_decode_end,
4062 .decode = vc1_decode_frame,
4063 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
4064 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
4065 .pix_fmts = ff_hwaccel_pixfmt_list_420,
4066 .profiles = NULL_IF_CONFIG_SMALL(profiles)
4070 #if CONFIG_WMV3_VDPAU_DECODER
4071 AVCodec ff_wmv3_vdpau_decoder = {
4072 .name = "wmv3_vdpau",
4073 .type = AVMEDIA_TYPE_VIDEO,
4074 .id = CODEC_ID_WMV3,
4075 .priv_data_size = sizeof(VC1Context),
4076 .init = vc1_decode_init,
4077 .close = vc1_decode_end,
4078 .decode = vc1_decode_frame,
4079 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
4080 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
4081 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE},
4082 .profiles = NULL_IF_CONFIG_SMALL(profiles)
4086 #if CONFIG_VC1_VDPAU_DECODER
4087 AVCodec ff_vc1_vdpau_decoder = {
4088 .name = "vc1_vdpau",
4089 .type = AVMEDIA_TYPE_VIDEO,
4091 .priv_data_size = sizeof(VC1Context),
4092 .init = vc1_decode_init,
4093 .close = vc1_decode_end,
4094 .decode = vc1_decode_frame,
4095 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
4096 .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
4097 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE},
4098 .profiles = NULL_IF_CONFIG_SMALL(profiles)
4102 #if CONFIG_WMV3IMAGE_DECODER
4103 AVCodec ff_wmv3image_decoder = {
4104 .name = "wmv3image",
4105 .type = AVMEDIA_TYPE_VIDEO,
4106 .id = CODEC_ID_WMV3IMAGE,
4107 .priv_data_size = sizeof(VC1Context),
4108 .init = vc1_decode_init,
4109 .close = vc1_decode_end,
4110 .decode = vc1_decode_frame,
4111 .capabilities = CODEC_CAP_DR1,
4112 .flush = vc1_sprite_flush,
4113 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
4114 .pix_fmts = ff_pixfmt_list_420
4118 #if CONFIG_VC1IMAGE_DECODER
4119 AVCodec ff_vc1image_decoder = {
4121 .type = AVMEDIA_TYPE_VIDEO,
4122 .id = CODEC_ID_VC1IMAGE,
4123 .priv_data_size = sizeof(VC1Context),
4124 .init = vc1_decode_init,
4125 .close = vc1_decode_end,
4126 .decode = vc1_decode_frame,
4127 .capabilities = CODEC_CAP_DR1,
4128 .flush = vc1_sprite_flush,
4129 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
4130 .pix_fmts = ff_pixfmt_list_420